{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4b954595",
   "metadata": {},
   "source": [
    "**1. 数据生成模块**\n",
    "负责人：钟建洲\n",
    "任务：\n",
    "设计车辆数据生成逻辑（到达时间、停留时长）。\n",
    "生成车位信息（距离入口的距离，如50m、100m等）。\n",
    "输出标准化数据格式供其他模块使用（如JSON或列表）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "c49f6aa9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"cars\": [\n",
      "        {\n",
      "            \"car_id\": \"car 1\",\n",
      "            \"arrival_time\": \"16:19\",\n",
      "            \"departure_time\": \"17:19\",\n",
      "            \"duration\": 1,\n",
      "            \"assigned_spot\": \"Spot 11\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 2\",\n",
      "            \"arrival_time\": \"13:19\",\n",
      "            \"departure_time\": \"16:19\",\n",
      "            \"duration\": 3,\n",
      "            \"assigned_spot\": \"Spot 13\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 3\",\n",
      "            \"arrival_time\": \"22:19\",\n",
      "            \"departure_time\": \"01:19\",\n",
      "            \"duration\": 3,\n",
      "            \"assigned_spot\": \"Spot 2\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 4\",\n",
      "            \"arrival_time\": \"16:19\",\n",
      "            \"departure_time\": \"20:19\",\n",
      "            \"duration\": 4,\n",
      "            \"assigned_spot\": \"Spot 3\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 5\",\n",
      "            \"arrival_time\": \"19:19\",\n",
      "            \"departure_time\": \"20:19\",\n",
      "            \"duration\": 1,\n",
      "            \"assigned_spot\": \"Spot 12\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 6\",\n",
      "            \"arrival_time\": \"16:19\",\n",
      "            \"departure_time\": \"18:19\",\n",
      "            \"duration\": 2,\n",
      "            \"assigned_spot\": \"Spot 9\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 7\",\n",
      "            \"arrival_time\": \"13:19\",\n",
      "            \"departure_time\": \"16:19\",\n",
      "            \"duration\": 3,\n",
      "            \"assigned_spot\": \"Spot 14\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 8\",\n",
      "            \"arrival_time\": \"22:19\",\n",
      "            \"departure_time\": \"00:19\",\n",
      "            \"duration\": 2,\n",
      "            \"assigned_spot\": \"Spot 3\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 9\",\n",
      "            \"arrival_time\": \"17:19\",\n",
      "            \"departure_time\": \"19:19\",\n",
      "            \"duration\": 2,\n",
      "            \"assigned_spot\": \"Spot 9\"\n",
      "        },\n",
      "        {\n",
      "            \"car_id\": \"car 10\",\n",
      "            \"arrival_time\": \"20:19\",\n",
      "            \"departure_time\": \"21:19\",\n",
      "            \"duration\": 1,\n",
      "            \"assigned_spot\": \"Spot 10\"\n",
      "        }\n",
      "    ],\n",
      "    \"spots\": [\n",
      "        50,\n",
      "        100,\n",
      "        150,\n",
      "        200,\n",
      "        250,\n",
      "        50,\n",
      "        100,\n",
      "        150,\n",
      "        200,\n",
      "        250,\n",
      "        50,\n",
      "        100,\n",
      "        150,\n",
      "        200,\n",
      "        250\n",
      "    ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import seaborn as sns\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import matplotlib.patches as patches\n",
    "import matplotlib.pyplot as plt\n",
    "import heapq\n",
    "import random\n",
    "import json\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "\n",
    "def generate_car_data(num_cars, num_spots):\n",
    "    cars = []\n",
    "    spots = [f\"Spot {i+1}\" for i in range(num_spots)]\n",
    "    # 50m, 100m, 150m, etc.\n",
    "    spot_distances = [50 + 50 * (i % 5) for i in range(num_spots)]\n",
    "\n",
    "    for i in range(num_cars):\n",
    "        arrival_time = datetime.now() + timedelta(hours=random.randint(0, 10))\n",
    "        duration_hours = random.randint(1, 4)\n",
    "        duration = timedelta(hours=duration_hours)\n",
    "        departure_time = arrival_time + duration\n",
    "\n",
    "        car = {\n",
    "            \"car_id\": f\"car {i+1}\",\n",
    "            \"arrival_time\": arrival_time.strftime(\"%H:%M\"),\n",
    "            \"departure_time\": departure_time.strftime(\"%H:%M\"),\n",
    "            \"duration\": duration_hours,\n",
    "            \"assigned_spot\": random.choice(spots)\n",
    "        }\n",
    "        cars.append(car)\n",
    "\n",
    "    return cars, spot_distances\n",
    "\n",
    "\n",
    "def main():\n",
    "    num_cars = 10  # 可以调整为10到20之间的任意值\n",
    "    num_spots = 15     # 可以调整为10到20之间的任意值\n",
    "\n",
    "    cars, spot_distances = generate_car_data(num_cars, num_spots)\n",
    "\n",
    "    data = {\n",
    "        \"cars\": cars,\n",
    "        \"spots\": spot_distances\n",
    "    }\n",
    "\n",
    "    print(json.dumps(data, indent=4))\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7f2dc0f",
   "metadata": {},
   "source": [
    "**2.贪心算法实现**\n",
    "负责人：黎荣、郭启荣\n",
    "任务：\n",
    "实现贪心算法核心逻辑：新车辆优先分配距离入口最近的空闲车位。\n",
    "处理实时分配请求，更新车位状态。\n",
    "与数据模块和输出模块对接。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "8eeb9bea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== 贪心算法测试 ===\n",
      "测试1 - 车辆A1分配到车位 1 (预期: 1)，预计离开时间 11:00 (预期: 11:00)\n",
      "测试2 - 车辆B2分配到车位 2 (预期: 2)，预计离开时间 11.5:30 (预期: 12:00)\n",
      "测试3 - 车位1已释放，当前可用车位: [1, 4, 3] (预期包含: [1])\n",
      "测试4 - 车辆C3分配到车位 1 (预期: 1)，预计离开时间 16:00 (预期: 16:00)\n",
      "=== 测试完成 ===\n"
     ]
    }
   ],
   "source": [
    "class ParkingScheduler:\n",
    "    def __init__(self, parking_spots):\n",
    "        \"\"\"\n",
    "        初始化停车场调度系统\n",
    "        :param parking_spots: 车位列表，每个元素为(距离入口距离, 车位编号)\n",
    "        \"\"\"\n",
    "        # 使用最小堆管理空闲车位（按距离排序）\n",
    "        self.available_spots = []\n",
    "        for distance, spot_id in parking_spots:\n",
    "            heapq.heappush(self.available_spots, (distance, spot_id))\n",
    "\n",
    "        # 记录占用中的车位 {车位编号: (车辆ID, 离开时间)}\n",
    "        self.occupied_spots = {}\n",
    "\n",
    "    def assign_spot(self, vehicle_id, arrival_time, duration):\n",
    "        \"\"\"\n",
    "        为车辆分配车位（贪心算法：选择最近的可用车位）\n",
    "        :param vehicle_id: 车辆ID\n",
    "        :param arrival_time: 到达时间（格式: 'HH:MM'）\n",
    "        :param duration: 停留时长（小时）\n",
    "        :return: (分配的车位编号, 预计离开时间) 或 None（如果没有可用车位）\n",
    "        \"\"\"\n",
    "        if not self.available_spots:\n",
    "            return None\n",
    "\n",
    "        # 获取最近的车位\n",
    "        distance, spot_id = heapq.heappop(self.available_spots)\n",
    "\n",
    "        # 计算离开时间\n",
    "        leave_time = self._calculate_leave_time(arrival_time, duration)\n",
    "\n",
    "        # 记录占用信息\n",
    "        self.occupied_spots[spot_id] = (vehicle_id, leave_time)\n",
    "\n",
    "        return spot_id, leave_time\n",
    "\n",
    "    def release_spot(self, spot_id):\n",
    "        \"\"\"释放车位，将其重新加入可用队列\"\"\"\n",
    "        if spot_id in self.occupied_spots:\n",
    "            distance = self._get_distance_by_spot_id(spot_id)\n",
    "            heapq.heappush(self.available_spots, (distance, spot_id))\n",
    "            del self.occupied_spots[spot_id]\n",
    "\n",
    "    def _calculate_leave_time(self, arrival_time, duration):\n",
    "        \"\"\"计算离开时间（简化版）\"\"\"\n",
    "        hours = int(arrival_time.split(':')[0]) + duration\n",
    "        return f\"{hours}:{arrival_time.split(':')[1]}\"\n",
    "\n",
    "    def _get_distance_by_spot_id(self, spot_id):\n",
    "        \"\"\"根据车位ID查找距离（简化版）\"\"\"\n",
    "        for dist, sid in self.available_spots:\n",
    "            if sid == spot_id:\n",
    "                return dist\n",
    "        for sid, (_, _) in self.occupied_spots.items():\n",
    "            if sid == spot_id:\n",
    "                return 50  # 默认距离，实际应从初始化数据获取\n",
    "        return 50\n",
    "\n",
    "\n",
    "# 测试用例\n",
    "print(\"=== 贪心算法测试 ===\")\n",
    "parking_spots = [(50, 1), (100, 2), (150, 3), (200, 4)]\n",
    "scheduler = ParkingScheduler(parking_spots)\n",
    "\n",
    "# 测试1: 正常分配车位\n",
    "result1 = scheduler.assign_spot(\"A1\", \"09:00\", 2)\n",
    "print(f\"测试1 - 车辆A1分配到车位 {result1[0]} (预期: 1)，预计离开时间 {result1[1]} (预期: 11:00)\")\n",
    "\n",
    "# 测试2: 分配第二个车位\n",
    "result2 = scheduler.assign_spot(\"B2\", \"10:30\", 1.5)\n",
    "print(f\"测试2 - 车辆B2分配到车位 {result2[0]} (预期: 2)，预计离开时间 {result2[1]} (预期: 12:00)\")\n",
    "\n",
    "# 测试3: 释放车位1\n",
    "scheduler.release_spot(1)\n",
    "print(\n",
    "    f\"测试3 - 车位1已释放，当前可用车位: {[spot[1] for spot in scheduler.available_spots]} (预期包含: [1])\")\n",
    "\n",
    "# 测试4: 再次分配应优先使用最近释放的车位1\n",
    "result4 = scheduler.assign_spot(\"C3\", \"13:00\", 3)\n",
    "print(f\"测试4 - 车辆C3分配到车位 {result4[0]} (预期: 1)，预计离开时间 {result4[1]} (预期: 16:00)\")\n",
    "\n",
    "print(\"=== 测试完成 ===\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2150848a",
   "metadata": {},
   "source": [
    "**3. 回溯算法实现**\n",
    "负责人：李浦瑞\n",
    "任务：\n",
    "设计回溯算法处理预约冲突（如两车同时段预约同一车位）。\n",
    "优化回溯效率（如剪枝策略）。\n",
    "与贪心算法模块协同，处理冲突场景。\n",
    "**4. 调度系统整合**\n",
    "负责人：黎荣、郭启荣\n",
    "任务：\n",
    "整合贪心和回溯算法，设计调度流程（如先贪心，冲突时触发回溯）。\n",
    "处理车辆动态到达和离开的时序逻辑。\n",
    "确保模块间数据传递的准确性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "220c605a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "所有车辆成功分配：\n",
      "车辆A1 → 车位1，09:00 至 11:00\n",
      "车辆B2 → 车位2，10:00 至 12:00\n",
      "车辆C3 → 车位3，09:30 至 10:30\n"
     ]
    }
   ],
   "source": [
    "# 代码\n",
    "class BacktrackingScheduler:\n",
    "    def __init__(self, parking_spots):\n",
    "        \"\"\"\n",
    "        初始化：记录所有车位与距离（用于冲突处理时重新分配）\n",
    "        :param parking_spots: [(距离, 车位ID)]\n",
    "        \"\"\"\n",
    "        self.all_spots = sorted(parking_spots, key=lambda x: x[0])  # 按距离排序\n",
    "        self.assignments = {}  # {车辆ID: (车位ID, 起始时间, 结束时间)}\n",
    "\n",
    "    def assign_with_backtracking(self, car_list):\n",
    "        \"\"\"\n",
    "        尝试为所有车辆安排停车，处理冲突（使用回溯）\n",
    "        :param car_list: 每辆车包含 {car_id, arrival_time, duration}\n",
    "        :return: 分配成功或失败，及所有分配信息\n",
    "        \"\"\"\n",
    "        return self._backtrack(car_list, 0)\n",
    "\n",
    "    def _backtrack(self, cars, index):\n",
    "        if index == len(cars):\n",
    "            return True  # 所有车辆都安排好了\n",
    "\n",
    "        car = cars[index]\n",
    "        car_id = car[\"car_id\"]\n",
    "        start_time = self._str_to_minutes(car[\"arrival_time\"])\n",
    "        end_time = start_time + car[\"duration\"] * 60\n",
    "\n",
    "        for distance, spot_id in self.all_spots:\n",
    "            if self._is_spot_available(spot_id, start_time, end_time):\n",
    "                self.assignments[car_id] = (spot_id, start_time, end_time)\n",
    "                if self._backtrack(cars, index + 1):  # 递归处理下一个车辆\n",
    "                    return True\n",
    "                del self.assignments[car_id]  # 回溯：取消当前分配\n",
    "\n",
    "        return False  # 无法为当前车辆找到合适车位\n",
    "\n",
    "    def _is_spot_available(self, spot_id, start, end):\n",
    "        \"\"\"\n",
    "        判断该车位在[start, end]时间内是否冲突\n",
    "        \"\"\"\n",
    "        for assigned in self.assignments.values():\n",
    "            s_id, s_start, s_end = assigned\n",
    "            if s_id == spot_id:\n",
    "                # 冲突条件：时间重叠\n",
    "                if not (end <= s_start or start >= s_end):\n",
    "                    return False\n",
    "        return True\n",
    "\n",
    "    def _str_to_minutes(self, time_str):\n",
    "        \"\"\"'HH:MM' -> 分钟数\"\"\"\n",
    "        h, m = map(int, time_str.split(\":\"))\n",
    "        return h * 60 + m\n",
    "\n",
    "    def get_assignments(self):\n",
    "        \"\"\"返回最终分配结果（修正版）\"\"\"\n",
    "        readable = {}\n",
    "        for car_id, (spot_id, start, end) in self.assignments.items():\n",
    "            readable[car_id] = {\n",
    "                \"spot_id\": spot_id,\n",
    "                \"car_id\": car_id,  # 确保包含car_id\n",
    "                \"arrival_time\": f\"{start // 60:02d}:{start % 60:02d}\",\n",
    "                \"leave_time\": f\"{end // 60:02d}:{end % 60:02d}\"\n",
    "            }\n",
    "        return readable\n",
    "\n",
    "\n",
    "\n",
    "# 模拟数据：调用数据模块的输出\n",
    "car_list = [\n",
    "    {\"car_id\": \"A1\", \"arrival_time\": \"09:00\", \"duration\": 2},\n",
    "    {\"car_id\": \"B2\", \"arrival_time\": \"10:00\", \"duration\": 2},\n",
    "    {\"car_id\": \"C3\", \"arrival_time\": \"09:30\", \"duration\": 1},\n",
    "]\n",
    "\n",
    "parking_spots = [(50, 1), (100, 2), (150, 3)]  # 距离 + 车位ID\n",
    "\n",
    "# 创建回溯调度器\n",
    "bt_scheduler = BacktrackingScheduler(parking_spots)\n",
    "\n",
    "# 执行分配\n",
    "success = bt_scheduler.assign_with_backtracking(car_list)\n",
    "\n",
    "if success:\n",
    "    print(\"所有车辆成功分配：\")\n",
    "    for car_id, info in bt_scheduler.get_assignments().items():\n",
    "        print(\n",
    "            f\"车辆{car_id} → 车位{info['spot_id']}，{info['arrival_time']} 至 {info['leave_time']}\")\n",
    "else:\n",
    "    print(\"无法为所有车辆安排无冲突车位。\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b32aa95d",
   "metadata": {},
   "source": [
    "**4. 调度系统整合**\n",
    "负责人：黎荣、郭启荣\n",
    "任务：\n",
    "整合贪心和回溯算法，设计调度流程（如先贪心，冲突时触发回溯）。\n",
    "处理车辆动态到达和离开的时序逻辑。\n",
    "确保模块间数据传递的准确性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "fb0cfead",
   "metadata": {},
   "outputs": [],
   "source": [
    "class IntegratedScheduler:\n",
    "    def __init__(self, parking_spots):\n",
    "        \"\"\"\n",
    "        初始化整合调度系统\n",
    "        :param parking_spots: [(距离, 车位ID)]\n",
    "        \"\"\"\n",
    "        # 贪心算法组件\n",
    "        self.greedy_scheduler = ParkingScheduler(parking_spots)\n",
    "\n",
    "        # 回溯算法组件\n",
    "        self.backtracking_scheduler = BacktrackingScheduler(parking_spots)\n",
    "\n",
    "        # 记录所有车辆信息\n",
    "        self.all_cars = []\n",
    "\n",
    "        # 冲突记录\n",
    "        self.conflicts = []\n",
    "\n",
    "    def process_car(self, car_data):\n",
    "        \"\"\"修正后的车辆处理方法\"\"\"\n",
    "        # 确保duration是整数\n",
    "        car_data[\"duration\"] = int(car_data[\"duration\"])\n",
    "        \n",
    "        # 先释放已离开的车位\n",
    "        current_time = self._time_to_minutes(car_data[\"arrival_time\"])\n",
    "        for spot_id, (_, leave_time) in list(self.greedy_scheduler.occupied_spots.items()):\n",
    "            leave_min = self._time_to_minutes(leave_time)\n",
    "            if leave_min <= current_time:\n",
    "                self.greedy_scheduler.release_spot(spot_id)\n",
    "\n",
    "        # 尝试贪心分配\n",
    "        result = self.greedy_scheduler.assign_spot(\n",
    "            car_data[\"car_id\"],\n",
    "            car_data[\"arrival_time\"],\n",
    "            car_data[\"duration\"]\n",
    "        )\n",
    "\n",
    "        if result is None:\n",
    "            self.conflicts.append(car_data[\"car_id\"])\n",
    "            return False\n",
    "\n",
    "        spot_id, leave_time = result\n",
    "        \n",
    "        # 检查是否与已有分配冲突\n",
    "        conflict = False\n",
    "        for car in self.all_cars:\n",
    "            if car[\"spot_id\"] == spot_id:\n",
    "                if self._check_time_conflict(\n",
    "                    car_data[\"arrival_time\"],\n",
    "                    leave_time,\n",
    "                    car[\"arrival_time\"],\n",
    "                    car[\"leave_time\"]\n",
    "                ):\n",
    "                    conflict = True\n",
    "                    break\n",
    "\n",
    "        if conflict:\n",
    "            print(f\"\\n检测到冲突 - 车辆 {car_data['car_id']} 与车位 {spot_id} 现有分配冲突\")\n",
    "            print(\"触发回溯算法...\")\n",
    "            \n",
    "            # 添加当前车辆到待分配列表\n",
    "            temp_car = {\n",
    "                \"car_id\": car_data[\"car_id\"],\n",
    "                \"arrival_time\": car_data[\"arrival_time\"],\n",
    "                \"duration\": car_data[\"duration\"],\n",
    "                \"spot_id\": None,\n",
    "                \"leave_time\": None\n",
    "            }\n",
    "            self.all_cars.append(temp_car)\n",
    "            \n",
    "            # 创建用于回溯的车辆列表\n",
    "            backtrack_cars = [{\n",
    "                \"car_id\": car[\"car_id\"],\n",
    "                \"arrival_time\": car[\"arrival_time\"],\n",
    "                \"duration\": int(car[\"duration\"])  # 确保是整数\n",
    "            } for car in self.all_cars]\n",
    "            \n",
    "            success = self.backtracking_scheduler.assign_with_backtracking(backtrack_cars)\n",
    "            print(f\"回溯结果: {'成功' if success else '失败'}\")\n",
    "            \n",
    "            if success:\n",
    "                print(\"同步调度器状态...\")\n",
    "                # 更新分配信息\n",
    "                self.all_cars = []\n",
    "                for car_id, (spot_id, start, end) in self.backtracking_scheduler.assignments.items():\n",
    "                    self.all_cars.append({\n",
    "                        \"car_id\": car_id,\n",
    "                        \"arrival_time\": self._minutes_to_time(start),\n",
    "                        \"leave_time\": self._minutes_to_time(end),\n",
    "                        \"duration\": (end-start)/60,\n",
    "                        \"spot_id\": spot_id\n",
    "                    })\n",
    "                self._sync_schedulers()\n",
    "                return True\n",
    "            else:\n",
    "                print(\"回溯失败，记录冲突\")\n",
    "                self.conflicts.append(car_data[\"car_id\"])\n",
    "                # 移除临时添加的车辆\n",
    "                self.all_cars = [car for car in self.all_cars if car[\"car_id\"] != car_data[\"car_id\"]]\n",
    "                # 释放可能已分配的车位\n",
    "                if spot_id in self.greedy_scheduler.occupied_spots:\n",
    "                    self.greedy_scheduler.release_spot(spot_id)\n",
    "                return False\n",
    "        else:\n",
    "            # 无冲突，记录分配\n",
    "            self.all_cars.append({\n",
    "                \"car_id\": car_data[\"car_id\"],\n",
    "                \"arrival_time\": car_data[\"arrival_time\"],\n",
    "                \"duration\": car_data[\"duration\"],\n",
    "                \"spot_id\": spot_id,\n",
    "                \"leave_time\": leave_time\n",
    "            })\n",
    "            return True\n",
    "\n",
    "    def _minutes_to_time(self, minutes):\n",
    "        \"\"\"将分钟数转换为HH:MM格式字符串\"\"\"\n",
    "        minutes = int(minutes)  # 确保是整数\n",
    "        return f\"{minutes//60:02d}:{minutes%60:02d}\"\n",
    "\n",
    "    def _check_time_conflict(self, start1, end1, start2, end2):\n",
    "        \"\"\"检查两个时间段是否重叠\"\"\"\n",
    "        start1 = self._time_to_minutes(start1)\n",
    "        end1 = self._time_to_minutes(end1)\n",
    "        start2 = self._time_to_minutes(start2)\n",
    "        end2 = self._time_to_minutes(end2)\n",
    "\n",
    "        # 允许前车刚离开时后车到达 (end1 == start2 不算冲突)\n",
    "        if end1 <= start2 or start1 >= end2:\n",
    "            return False\n",
    "        return True\n",
    "\n",
    "    def _time_to_minutes(self, time_str):\n",
    "        \"\"\"HH:MM -> 分钟数\"\"\"\n",
    "        h, m = map(int, time_str.split(\":\"))\n",
    "        return h * 60 + m\n",
    "\n",
    "    def _sync_schedulers(self):\n",
    "        \"\"\"同步两个调度器的状态\"\"\"\n",
    "        # 清空贪心调度器的分配\n",
    "        self.greedy_scheduler.occupied_spots = {}\n",
    "        self.greedy_scheduler.available_spots = []\n",
    "\n",
    "        # 根据回溯结果重建贪心调度器状态\n",
    "        for car in self.all_cars:\n",
    "            if car[\"spot_id\"] is not None:\n",
    "                self.greedy_scheduler.occupied_spots[car[\"spot_id\"]] = (\n",
    "                    car[\"car_id\"],\n",
    "                    car[\"leave_time\"]\n",
    "                )\n",
    "\n",
    "        # 重建可用车位，确保按距离排序\n",
    "        available_spots = []\n",
    "        for distance, spot_id in self.backtracking_scheduler.all_spots:\n",
    "            if spot_id not in self.greedy_scheduler.occupied_spots:\n",
    "                heapq.heappush(available_spots, (distance, spot_id))\n",
    "\n",
    "        # 更新可用车位列表\n",
    "        self.greedy_scheduler.available_spots = available_spots\n",
    "\n",
    "    def get_assignments(self):\n",
    "        \"\"\"获取最终分配结果（修正版）\"\"\"\n",
    "        assignments = {}\n",
    "        \n",
    "        # 合并贪心和回溯的分配结果\n",
    "        for car in self.all_cars:\n",
    "            if car[\"spot_id\"] is not None:\n",
    "                assignments[car[\"car_id\"]] = {\n",
    "                    \"spot_id\": car[\"spot_id\"],\n",
    "                    \"car_id\": car[\"car_id\"],  # 确保包含car_id\n",
    "                    \"arrival_time\": car[\"arrival_time\"],\n",
    "                    \"leave_time\": car[\"leave_time\"]\n",
    "                }\n",
    "        \n",
    "        # 添加回溯算法成功分配的车辆\n",
    "        if hasattr(self, 'backtracking_scheduler'):\n",
    "            bt_assignments = self.backtracking_scheduler.get_assignments()\n",
    "            for car_id, info in bt_assignments.items():\n",
    "                if car_id not in assignments:  # 避免覆盖\n",
    "                    assignments[car_id] = info\n",
    "        \n",
    "        return assignments\n",
    "\n",
    "    def get_conflicts(self):\n",
    "        \"\"\"获取冲突车辆列表\"\"\"\n",
    "        return self.conflicts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc1fa1ab",
   "metadata": {},
   "source": [
    "**5. 输出与可视化**\n",
    "负责人：廖伟雄\n",
    "任务：\n",
    "生成车位分配表（如“车辆A1→车位3”）。\n",
    "可选：可视化调度结果（如时间轴甘特图或停车场平面图）。\n",
    "设计用户友好的输出格式（控制台/文件/图形界面）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "738785c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "处理车辆 A1: 成功\n",
      "处理车辆 B2: 成功\n",
      "处理车辆 C3: 成功\n",
      "处理车辆 D4: 成功\n",
      "\n",
      "检测到冲突 - 车辆 E5 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "处理车辆 E5: 失败\n",
      "\n",
      "当前占用车位: {2: ('B2', '12:00'), 1: ('D4', '14:00')}\n",
      "可用车位: [3]\n",
      "\n",
      "创建可视化工具...\n",
      "\n",
      "=== 生成详细报告 ===\n",
      "==================================================\n",
      "停车场调度系统 - 分配报告\n",
      "生成时间: 2025-06-17 12:19:30\n",
      "==================================================\n",
      "\n",
      "[车位分配情况]\n",
      "\n",
      "车位 1:\n",
      "  - 车辆 A1: 09:00 至 11:00\n",
      "  - 车辆 D4: 11:00 至 14:00\n",
      "\n",
      "车位 2:\n",
      "  - 车辆 B2: 10:00 至 12:00\n",
      "\n",
      "车位 3:\n",
      "  - 车辆 C3: 09:30 至 10:30\n",
      "\n",
      "[冲突信息]\n",
      "以下 1 辆车未能分配车位:\n",
      "E5\n",
      "\n",
      "[统计摘要]\n",
      "车位总数: 3\n",
      "已占用车位: 3\n",
      "空闲车位: 0\n",
      "车位利用率: 100.0%\n",
      "冲突车辆数: 1\n",
      "\n",
      "=== 生成综合仪表盘 ===\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\86150\\AppData\\Local\\Temp\\ipykernel_33556\\1027364159.py:120: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([minutes_to_time(x) for x in ax.get_xticks()])\n",
      "c:\\ProgramData\\anaconda3\\Lib\\site-packages\\seaborn\\_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjUAAAScCAYAAADDDw0GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZyN5f/H8fc5Z3YzjDF2xr5lyxZJKLK3+FIRiqIsJRH1LZU9okLiG0lFoUWWRCZKSGTNMJZsYxscjDHLmZlzzv37Y8z5zTGLIeYYXs/H4zyac93XfV+f+xg69/25r+tjMgzDEAAAAAAAAAAAwC3O7OkAAAAAAAAAAAAAcoKkBgAAAAAAAAAAyBNIagAAAAAAAAAAgDyBpAYAAAAAAAAAAMgTSGoAAAAAAAAAAIA8gaQGAAAAAAAAAADIE0hqAAAAAAAAAACAPIGkBgAAAAAAAAAAyBNIagAAACCD2NhYJSUlZdvn4MGD2r17978e6+zZs4qKivrXx8GtYceOHZ4O4aYzDONfH+PkyZOy2+3/6hgHDhzQ4sWLM40nISFB33//vRwOx78a42Y7evSop0MAAABAHkNSAwAAABl89tlnKlSokD777LNMt2/atEkVK1bU0KFDb8hY5cuX1zvvvHPdx9i4caN69uyp8PBwV5vVatVzzz2nAQMG6OWXX9agQYOyfJ0/fz7T454+fVonTpy47riux9KlS9WgQQO3c7lZ4uLitHbtWr333nt64YUXZLPZsux75swZjR8/XmfPns2yz+uvv646depo+fLlNyPcm2rDhg1XTVZ8/vnnKlGihCZPnvyvx3viiSdUs2ZN7d+//7qPMX/+fHXs2FFPP/10hm0dOnRQ586dtWnTpn8TpktsbKyKFSumhg0b3pDjSVJ0dLTKli2rMmXKKC4u7oYdFwAAALc3L08HAAAAgFvP77//rsTERLVq1Up///23Tp06JV9fX3l5/f/Xx+DgYK1evVpr1qyRj4+PpNQn2O12u0wmk5o3b37VcZxOpz777DM5nU61bdv2uuONjo7WF198oSZNmrja4uLi9MUXX8jX11e+vr6uGCUpKSlJMTExkiQfH59MkzNxcXFq0KCBChQooPXr16tAgQKSpHXr1qlp06Y5ju2DDz7QK6+8kuP+vr6+2rJli6ZOnaqHHnoox/s5HA7t379fTqdTDodDNptNNptNcXFxio2N1fnz53X27FkdOXJEhw8f1qFDh3TixAk5nU63c543b55MJlOG4//444/673//q2XLlmnDhg2ZxtC3b1+9//77GjJkiFq3bu32+3Irs1qtatq0qSpXrqwtW7YoX758mfYrU6aMTp06pd9+++2a/kyvNH/+fNdnGBERocqVK1/XcX744QeZTCa9/vrrGba1aNFCv/76q1auXKnGjRtLSv17UqxYsesay9fXV6dPn1aZMmWua/80sbGxrt+5VatWSZLatm0ru93u+juZnre3d5Z/HgAAALgz5Y2rDAAAAOSahIQEhYeHq2nTpipVqpTGjBmjTz75JMv+LVq0yNBWoUIF/fPPP673cXFxMgxDPj4+8vLyksVikSQtWbJE+/fvV9++fdWoUaNMj5+SkqLExET5+PjIz88v0z5p7b6+vq62smXLZrq8z8WLF/XQQw/pr7/+Ut++fTV69GiFhoZm6BcYGKg333xTffv21ZNPPqnly5fLYrG4xhoxYoSefPJJ1/kdP35cJUuWVFBQkCRp79696tixY6Y3ZCdMmJDlrACHwyGLxaKVK1dq3LhxMpv/f3K13W6XzWZT6dKl9cILL7jtZ7FY9MQTTygiIsKt3d/fXz4+Prp48aLq1q2rypUr6+6771br1q1VvHhxFS5cWEWLFlWBAgUUGBgowzAyTWrMmjVLFotFM2bMcLVduHBBPj4+8vf3l9lsVtmyZfXWW2+patWqrrgNw3AlWIKCgm7JRMdPP/0kp9Op1q1bu/68UlJSMiyvlhb7unXrMiyzZTabVatWrauOdfjwYQ0YMEAlS5ZU7dq11aNHD5UqVUr33HPPNcW8Y8cO7dixQ4888oiqV68up9OpY8eOyWw2q3Tp0mrVqpWGDx+uX375RaNGjZIktWzZUufPn9fq1atVrVq1DMfcvHmzVq1apeDgYHl7e7v+nqZ34cIFffrppxnaHQ6HEhMTVa5cOT366KNZxl2vXj23fxsk6ZNPPsny35g2bdpoxYoV2X4WAAAAuLPcelcUAAAA8KhvvvlGcXFxrpkTo0aN0uuvvy5fX195e3tnu6/D4ZDdbs+wjv+LL76oL774Isv9/ve//+l///tftseeNWuWevfunem2tJvwmd2MT+/ChQtq3bq1tm/frs8//1zPPPNMtv1feOEFrV+/XvPmzdN3332nJ5980jXjo2jRoqpataokacWKFerYsaN++OEHPfbYY5LkWsops5v4b7/9tiSpYMGCmY6blmSZOnWqq80wDKWkpCgpKUlNmjTJkNSQUpNECQkJCgkJUVBQkAIDA2UymfTiiy/q448/VkxMjD766KNMkzjZ+eOPP/Tnn3/qxRdfdLtxX6dOnWuqibB9+3bdfffd1zR2bvjyyy8VFBSk4cOHu9piY2NVp06dTPtfuHAhw7bChQvrzJkz2Y6TmJiozp07Ky4uTj/++KNq1qypRo0aqV27dvrtt99Uo0aNHMf80UcfSZL69esnSdqzZ49q1qypp59+Wl988YXq1KmjgIAAbdmyRYmJiUpJSVFkZKQKFiyY5cyQv//+W2+99Va24x44cEB9+vTJcvuTTz6ZbVIjLWn03nvvyd/fX5J0/vx5hYSEZOj7xhtvuCUqAQAAAImkBgAAAK7w4YcfSpLrxmeRIkVks9l05MiRq+7r7++f6fI09913n7y8vOTj4yOz2SyLxaLff/9dO3bsUNu2bbO8yep0OpWUlKTk5GRVqlTp+k9KqfUxWrVqpQMHDmjJkiVq165djvabPn26WrZs6ZqVkX7mRGJiogzDcN2cDQgIUFJSktssjPT903h7e6tx48au5XckKTw8XMuXL1efPn1UvXp1V/vRo0f12muvqWXLllkmddKUL18+Q9tnn32mjz/+WFWqVNGCBQvcEhoTJkzQpUuXNHz48CxnwUips1JCQkI0cuRISanJnk6dOmn48OGy2+2uP9cJEyaoV69eKlKkiGvftJkaiYmJKlGiRLbxe8KhQ4e0Zs0aDR8+XKGhoVq3bp3Kly/v+pw6dOhw1XovTZs2df0OZCUpKUmPPfaYtm3bpmnTprmWhFq+fLnuvfdePfDAA1qxYoXq169/1ZitVqvmz5+vQoUKqVWrVpKkqlWrys/Pz1VDw8vLSy1btpS3t7diYmK0Z88eOZ1OPfzww5nOwJCkzp0766GHHlL+/PmVP3/+DP28vLzUpEkT/fbbbxn2dTgcunTpkpKSkrKNPe33rE+fPgoODtaxY8dUu3ZtNW/eXO+9954qVqzo6jtmzBi3ZeMAAAAAiaQGAAAA0lm2bJn+/vvvDO379+9X7dq1r7r/vffeqz/++CNDe58+fdye7j516pS+/PJL1a5dWz/88IO8vb1dT8t36tQpR7GePn1au3fvlq+vr6vY8qFDh7R+/XolJSWpefPmrpuy+/btU4cOHXTmzBn9/PPPuv/++3M0hiQFBQW5zehIf6N35MiRmjBhgut969atJUnvvPOOa8ZGZiwWS4ZZJZGRkZoyZYoeffRRt6RGcnKyFi5cqKJFi+Y4Zik1mfDee+/pv//9r5544gl99tlnrqfkz58/r2effVZLliyRt7e3HA6H3n333UyP88MPPyg8PFwzZsxQSEiINm3apJkzZ2ru3LnavXu3ypUrJ0k6ePCgnn32WU2dOlUREREKDg6+png95YMPPlC+fPk0aNAgSamJng0bNujHH3+UJBUqVOiqiQaz2azExMQst8fFxemJJ57QqlWr9M4772jAgAGubWXLltWqVav04IMPqmnTppo0aZL69euX7ayjCRMmKDExUUWKFHElzby8vFSjRg1t3brVNfNhyZIlrn3Slg3r2LFjlscNDg5WdHS0lixZIj8/vwwJOcMwdOrUqQzLTzkcDiUlJalUqVL6z3/+k+XxMxMaGqrXX39do0ePVtu2bRUZGek2uymzpCAAAADubCQ1AAAAICn1hmXaskhXCggIkCTNnTtX3bt3z7RP8+bNr7r8k5Q6+6JHjx5KSUnRggUL5OvrK6fTqV69eqlq1ao5TmqsW7dOjz/+uFvbO++843qq/tKlS/Lz89Nnn32moUOHysvLS6tXr77qDeoTJ05o3rx5rjoRUupMk7TlhtKfY+fOnVWzZk1FRUXpjTfe0KhRo1SpUiXXslTZMZvN+uuvv7Ru3Tr5+/tr8+bNkqSVK1fq4MGDrn5Wq1VSamJm5syZSk5OVkBAgJ599tlMj3v8+HEtXLhQc+fO1c6dO/Xss89q6NChOnbsmKTU5YP69eun06dPq3///nr99ddVunTpTI/1yy+/qFevXipWrJjKli2rJUuWuG6Ov/fee66EhiSNHTtWhmFoypQproRGQkKCq47KrWjXrl2aOXOmBg0apJCQEJ04cUI///yzWrVqperVq+uZZ55xKz6flXHjxmW57ciRI3r00Uf1999/680339SIESMy9KlZs6Y2bNigdu3aacCAAVq4cKE++OAD1atXL0PfgwcPupaeulLLli21ZcsWLV++XD169HDbFh4eroCAgKsWn9+xY4defvnlLLfv378/y+Wn2rdvnyGpsXPnTu3fv19+fn7y8vLSxYsXJUmrV692Jdlq1aql9957T+fPn9cvv/zi2jc5OVnR0dH66aeflJKSouTk5Ax/5wEAAHAHMgAAAADDMObOnWtIMpo1a2ZIMn744QfXtn379hmSjPfee8+IjIzM9NWgQQPjwQcfvOo4gwcPNiQZ8+bNc2v38vIy7r777hzHe+bMGWPjxo3G9u3bjRkzZhiSjHHjxhlbt2411q5da5w+fdooUqSIISlHry+++MIwDMPYuHFjhm1Tp051jRsZGWlIMmbMmOFqS9vn119/dbVt377dkGTMmTMnQ+yBgYFG+/btjcmTJxt+fn5GSEiIERQUZEgyQkJCjKJFi7peoaGhhiQjICDACA0NNQoUKJDt5xQVFXXVc23RooWxe/fuq37GY8aMyXT/Ro0aGU6n09Vv/fr1hslkMgYOHOhqO3TokFGtWjXjpZdeuuo4nnDq1CmjTJkyhtlsNtasWWNERkYaAwcONPz9/Y2jR4+6+l24cMHYvHmzsXPnzgy/8zt27DA2bdpkJCYmZji+0+k0/ve//xlBQUGG2Ww2Ro8ebdhsNsPhcGQaj8PhMI4dO2a0adPGkGSYTCajdevWxvfff28kJCS4+jRv3tzw9vY2SpQoYZQpU8btGH/++achyXj00Ufd2i9cuGBYLBajY8eOV/1ckpKSjISEBMNut2fYZrFYjGbNmmUae1JSkhEXF5dh25tvvpnjv4NXe+XLl++q8QMAAOD2d2s+MgUAAIBcdfHiRb322mvKnz+/Ro0apWbNmrltT1taZ9iwYRo2bFiWx7nvvvuy3JacnKw33nhDH3zwgfr166du3bq5bff19c2w1IzdbldycrKSk5OVP39+t+2FCxdW4cKFJUnR0dGSpNKlS6tu3bquPnfddZcefPBBpaSk6Pvvv9fDDz+se+65Rx999JESExM1bNgwbdq0ST/++KOraHfaEj758uXT/v379cgjj7jVm3A6na6f169fL6vVqsOHD0uSNm3apEuXLslkMqlUqVJZfhZOp1Pe3t56+eWXXU/FT58+XQMGDNCSJUvcZgccOXJE5cqV00svvaTx48dnecw0pUuXVnh4uAoVKqQSJUooICBAH330kcaMGaNChQrp/fff1xNPPCFJ+u677zRz5kxNmzYt07omffv2VUpKimrVqqUKFSpo6NChWrNmjf73v/+5ZqycOHFCTz31lGrWrOm2FFfx4sWVL18+ffTRR6pfv76efvrpq8aem/Lly6eTJ0/K6XSqRYsW8vPzU2JiokaMGKGwsDBXvz///FNt27bN9lgHDhxwqwXx+++/a/Dgwdq6dasKFiyoZcuW6Y033rhqEW5Jmj9/vp566im9/vrr+vnnn/XHH39o27ZtqlixoiZNmqTffvtNQ4cO1e+//+76vU9zzz33qHTp0lq5cqXOnDnjqm3yww8/yOFwqHPnzpmO6XQ69fvvv7tmU2Tn0qVL2rJlS6bb0pahslgsrn8LevXqpbZt28rX11eGYej+++9XxYoVNW/ePEmpNWNKly6d6TJTderU0VNPPaXBgwfLbrfLZrNl/+EBAADgjkBSAwAAAPL399fjjz+uMmXKuBV5TkxMVHx8vEqWLKmzZ8/m6FhpyyUFBwe73SAdM2aM3n//fUmp6/unLWOU3rZt27Jcwurw4cMqW7ZsTk9JkvTrr79KkkaPHq3vv/9egwcPVpMmTTRu3Dg1bNhQw4cP1/vvv68ff/zRtRROYGCgKzGSlsxJfx5pSQ2TyaRp06Zp4cKFrm2vv/66JKlChQr67rvvsowrKSlJvr6+bm12u11S6pJI6aXduHY4HDk+75YtW0qSli5dqjfeeEP79+/XK6+8orffftt1nmlx/PHHH2rYsKEWLlzoKjqdplChQq7lkjZu3Kjw8HC9/PLLrvoqS5Ys0YABAxQTE6OffvpJiYmJOnnypM6ePatTp06pRYsW2rJliwYMGKD77rtPFSpUyPE5pJk9e7YraZSdV1999ZrqeAQFBembb75RlSpVVKFCBT3++OPasWNHhqRdo0aNtG3bNuXPn19BQUGum++GYSg2NlYXL17MkMAqUKCAjh49qgceeECff/65wsLCFBkZqYcfflheXl6ZFupOSUlRfHy8KleurLp166pTp06aMWOGvL29XQmTXr16KTw8XCNHjtQDDzyQ4Rgmk0kvvfSShg0bpqlTp2rMmDGSUhMlAQEBevjhhzP9LJKTkzM9Xma2bdumBg0aZNunQoUK+ueff1w/p/25L1++XElJSWrbtq3uvvtu2Ww2tW/fXoGBgRo6dKh69OiR4e9F4cKFM12GCwAAAHcukhoAAACQj4+PJk+eLMMwtG/fPlf7rFmzsl1fPztbtmxxuxn5xBNPaPTo0a5ZDKGhoa4nw00mkzZs2CB/f3+3fVJSUmSz2ZSUlCRvb+/risPpdGrevHkKDQ3Vfffdpx07digxMdFVWyMuLk5SajIjK+kTLUlJSZJSi31PnDhRo0ePlo+Pj8xms5xOp+x2u5xOp+Lj4zM9VnJyshwOh4KCgtza0/r3798/0/1y8pT6uXPntGPHDv3xxx9asGCB9uzZo/bt22vRokWqXLmynE6nYmNjFR8fr/j4eFWvXl2TJk3SwIED1b59e02fPj3TeglOp1MvvfSSihcvrlGjRrnao6OjdeLECUmpM1wyYzKZFBcXp+7du2v9+vWZ3tDPzty5c7V27dqr9uvdu/c1FydPK+a+Zs0aLV26VN9//738/f0lpZ5zWl2Wu+++O9NkW9pMIYfDofj4ePn4+Mjb21u1a9fWtm3bVKpUKdd+Q4YMuabYAgICMuxTuHBh/fzzz9kWz37hhRc0ZswYffzxxxo4cKASEhK0Zs0a9ejRI8PvXBofHx998803rsRNWg0dKXUmRdeuXWUYhhYuXCin06ng4OBMP2u73a7ExMRMi6ZbrVa9/PLL8vLycv2O+fn56euvv9bIkSPVp08fbdmyRePHj9fWrVt14MABSbruv/cAAAC4fZHUAAAAgMuVN27TbvDu3r3bbQZHdn7//Xd16tQpw83IGjVqaMeOHapQoUKmCYTg4GBVrFhRv/322/UFn4V58+Zp//79euONN+Tt7a3Vq1dLkh588EFJ/59MyJ8/f46Ol3bD1s/PTwUKFFB8fHyGm7iFCxfOMqkRExMjSQoJCZGUuvSXj4+PXn75Zb300ktZjpuTm7uLFi3S888/73rv6+uryMhINWnSRHFxcZnebE7v+eef19GjR11P+Kf54IMPtHXrVi1YsMD1OcXFxen++++Xj4+PypcvL6vVqvPnz2vUqFE6fPiwZs+erXnz5qlz585q2rSpqlSpIofDcc1JjRv9+3CluLg49evXTx06dHArcn3y5MksC6hn5YcffnAlStL2PX36tCIjI6/pOIGBgVkWtM8uoSGl/h4PHTpUb731lgYMGKASJUrI4XBo4MCBWe5jNpszLcB9/PhxPfHEE0pOTta3336rmjVrqlKlShoxYoSGDx/u6nf48GENHjxYn3zySab/TsTExKhJkyY6ePCg3nrrLbelzpo1a6Y1a9Zo5syZevTRR+Xn56eePXvq+PHjMplMatq0abbnCwAAgDsPSQ0AAABkqVSpUurWrZuCg4O1Z88eVaxYUUFBQRmSH2lL8ezbt0+VK1dWt27dMk1cpC1bdDPZbDbNmzdPDzzwgAzD0KBBg1SkSBG9+uqrklLrSAQEBLiW20lLPmT1FHua+Ph4xcXF6cKFC5KkggULavny5Xrqqacy9B05cqQeeeSRTI9z+vRpSf//lH+FChV07ty5HJ3bY489ph9++CHL7Z07d9bmzZtVunRpFS5cWEFBQQoKCpKvr698fX314osv6vz581q2bJkCAwMVFBSkfPnyKSAgQEePHlWzZs20atUq9e/fXyVKlJAkjRs3Tm+99Zb8/f31ww8/aOrUqTp8+LDi4uJ0+vRpxcXFydvbW126dNHixYv15ptvat68eZo9e7YKFSokX19frVy50lWz5FZy/Phx9erVS/v379dzzz2n0aNHa/fu3SpTpozeeOMNvfrqq/L395efn58rmTB27FgVLlzYlTwyDEM2m002m82trkaatWvX6sknn7ymuBo2bKg///zzus9r2LBh+vrrr/Xdd9/Jy8tLDz/8sOrUqXNNx/jjjz/0n//8R6dPn9aLL76ojh07SpLq1aunadOmaeDAgcqfP79iY2P18MMPa/fu3bLZbFq+fHmGxEtwcLC+++47ffHFFxo5cmSm46VPxn344YeKiYlRs2bNVKlSpWs8ewAAANzuSGoAAAAgS23btlXbtm115MiRDMXDs5KSkuIqAixJCQkJcjgc8vb2di3TdK0Mw3AVCvbz88ty1sKnn36qV155RVarVd99953eeustxcTEaNmyZSpYsKA2bNigLVu2qGfPnq7i3zmZqXHp0iW1a9dOFotFjz76qCSpRIkSMgxDkrR9+3bdfffdklJnu2R3jkeOHJEklS9fXpI0bdo0mUwmrVixQl988YXeffddVa1a1dXfZrOpb9++MpvN+uijj7L9nAoWLKhZs2bJ6XTq3LlzrsRJmqCgIMXHx7vNAjh48KCCg4NVqVIlrV+/XmFhYW41RNauXSun06mUlBRt27ZNlSpVUseOHVW/fn3XTB4pdcZDVp/hrZjQkKStW7fql19+kSS99tprKlGihMqUKaMOHTqoQIECmjhxYoZ9Jk+erLCwMFf9lKtJ+z2bNGmS63cnO5UqVXIrTH89fHx89Oqrr+q5556T3W53JSRyIjk5WWPHjtW7777raitQoIDr5xEjRqhdu3YaPHiw3n33XbVt21a7d+/W4MGDNWHChCx/94cPH64lS5Zo0qRJ13w+wcHBrmQiAAAAQFIDAAAAV1WiRAnt3LlT/v7+rhvZgwcP1s8//6zdu3dLSl2WKSEhwe2GuJT61PjHH3+co3G2bt2aZaHwNMuWLVOHDh0kSYcOHdL333+vuXPnSkotZt25c2eVL19e/fr109mzZzVt2jS1b99eDodDQ4cOlclkcluKJz4+XiaTKduaGkOHDpXT6dT8+fO1cOFCmc1mVa5cWSdPnsy0f1ox8czs2LFDklxPoHfp0kWS1KFDB/3+++/68ssvtXnzZlc8vXr1UmxsrBYvXpyhIHVWXnvtNc2ZM0fTp0/XE088kWW/Tz75RAMGDNCbb76pt99+25VoSW/SpElKSEhQ3bp1s10Ca//+/ddcyN3THnroIb355ptq2LCh7r33XoWGhmboExkZqZkzZ2r06NEZfkdWrlypP/74w63OyJXS/j4ULVo005kc2e1zvbZs2aJXX33VVZT8hRdeUFJSkvr27ZvlPoZhaMmSJXrjjTcUGRmp2rVra8KECWrTpo1bv7Zt26pTp06aPXu2fv75Z508eVIfffSRXnzxxWxjSvt3Y/z48SpUqJAk6fXXX1e1atX0zDPPSEqdHTJnzhy9//77rgTZ66+/Lh8fn+v+LAAAAHD7IakBAACAq/Lx8VGtWrXc2gICAlxFv7NTrFgx1apVSz4+PvL19c3yhu369eszFApP43A4ZLfblZCQ4Fom6t1339Ubb7whKXWZrLFjx6p3794qUqSIFi5cqPj4eH322Wfq1auXJOmdd97Rxo0b1b17d7eleOLj4xUYGJhpMmXnzp2SUpMU3333nR588EH17NlTdevWVb58+VxFxq9c2ichISHLzyNtKabq1au7tefLl08LFixQs2bN1KZNGy1btkzjxo3T559/rvfeey/L5ayuNHHiRE2aNEmVK1e+apKhTp06Kl++vEaNGqU1a9ZowYIFKlmypFufmjVrZtjv0qVLWrNmjUqXLq26devq77//1oEDB667qLynBAQEZKgfcqWBAwfql19+UcOGDV0JqDQffPCBwsPD5ePj41ZjIr2rJelutLlz56pfv37y8vLSihUrXLOL+vXrp59//lnTp09X8eLFM+z3zDPPaO7cubJYLHrllVc0btw4RUdHu/VxOp2aMmWKRo8ere3bt+vQoUN6+umnr5rQkP4/qfHkk0+6fi/HjBmjKlWqqHfv3pJSkzlz5szRU089pWLFirn6XM/sLgAAANy+SGoAAADATdqSStnNNrgWw4cPz/KGb3r58+dX5cqVc1wYesCAAVq6dKn69++vrl27uiVLnnzyST3wwAMqUqSInE6nRo4cqbFjx6p06dKaMmWK23FOnz6t4ODgTMf4559/5O3trW+++UaPPPKIPvjgA8XFxbmeLG/btm2mRaBDQkJ09OjRDO3R0dHatGmTHn300Uxv1N5zzz2aP3++nnzySVWoUEEXLlzQiBEjNHTo0Kt+HoZhaPjw4Ro3bpzuv/9+LV682FWMPCv33HOPtm7dql69eun7779XnTp1tHjxYjVu3Nit37lz57R9+3Zt3rxZ4eHh2rBhg1JSUjRr1izVqVNHw4YNkyR169Yt03EcDocmTZqkF154IcvP2pOOHz+uv//+W5s2bdLGjRtVoUIFzZgxQ9OmTdMvv/yixx9/PENCQ5K+/fZbNWnSRG+99ZaCgoIyTeqkJTUOHjz4r+pkXMkwDNff1bTjDx06VD/88IPKlSun5cuXq1q1apJSZzD95z//0eLFi7V69Wr169dPAwcOdEtgTZgwQfHx8XrrrbdcS6mlt337dvXr10+bNm1S/vz5tXLlSrVu3VpffvmlTp48qb59+6p169ZZznj6N4kJkhoAAABwYwAAAADpbN++3ZBkzJ8/P9t+Xbt2NQoUKHDDxg0ICDDq1Klzw45nGIaxf/9+49577zUkGYULFzZ27dplGIZhbNiwwViwYIExYsQIw2QyGc2aNct0f6fTaWzbts0wDMM4duyYERwcbAQGBhoXLlzIcsw9e/YYmzZtMrp06WJIMr766ivXtiFDhhiSjIULF2bY79KlS8bSpUuNzp07G97e3oYkQ5LRuHFjY+LEicb69euNS5cuZTpmdHS00apVK0OS8eijjxqJiYkZ+sTExBjFihUzKlSokOl5Dhs2zJBk3HXXXYbdbjcMwzB+//13o1ixYq5YzGazUb9+feO///2vsWbNGiMpKcl45513DElGp06dXMebO3euIcn44YcfDMMwjG3bthmSjBYtWmT5uXlC//79jUKFCrnOr0CBAkabNm2MTz/91Fi3bp3h4+NjlCtXzjh//rxrn+DgYKN58+au91FRUUaxYsUMk8lk/PTTTxnGWL58uev4OX09+OCDV429Xr16RvHixY29e/caTzzxhOt3plOnTsaZM2cy9I+NjTWeffZZt3EGDhyY7Ri7d+82JBlhYWGG2Ww2LBaL0atXL+Pw4cOGYRjG6dOnXb/nkgyLxWLUqlXLeOaZZ1y/Q2mee+45Q5JrX8MwjDJlyhjPPfec6/2cOXMMScapU6fc+mT2OwsAAIA7FzM1AAAA4CY5Odntv1d6/vnnFR0drfDwcNfa+DdCSkqKUlJSbtjxEhIS1KpVKx05ckR33323vv/+e1fNiNjYWLcn79OWqLqSyWRyLS01aNAgxcTEaOLEidnONhg+fLgWLVokKXXZrkaNGklKrTny+eefq1ixYurYsaPWrFmjTZs26fDhw9q1a5e2bt2qlJQUVaxYUcOHD1fHjh31888/a/78+Ro2bJjrqfzQ0FAVL15cd911l77++muZzWYVKlRIderUUenSpfXJJ5/IYrG44pk0aZJGjBjhKojeqlWrTM9zwoQJKlq0qDp37uzav0mTJipTpoyaNGmiRx99VG3btnX9mdvtdr3++ut6//33VbFiRc2aNct1vHz58kmSRo4cqV27dmn58uWSpKeffjrLz80TatSooV9++UUDBw5UmzZtVL9+fZnNZkVHR6tatWry9/fX4sWLVbBgQb3zzjtau3atYmJi3GbAlC5dWkuXLtXMmTPVsmXLDGPY7XZJqculpdWCyU7NmjVz9PfA4XAoMTFRpUqV0t69e1W6dGlNmzZNbdu2zbR/UFCQZs+erS5duujll1+W1WrV22+/ne0YP/30kyQpKipK9957r2bMmKHatWu7thcpUkTz58/X4MGD9dFHH+n777/X33//rccff1wWi0V79uzRl19+KX9/f9dSbjNmzHAVjr948aL+/vtvjR8/XlJqTR1JmjZtmmvGx8WLF2WxWDRu3DjZbDY1atRI7dq1u+rnAwAAgNuXyTDSzVkGAADAHW/dunVq2rSpZs2a5VrrPr1hw4Zp4sSJ8vHx0dixY/Xqq6/+6zEdDoe8vLxUqVIl7d+//18fL8369eu1cuVKvf32227FhlNSUtS3b19VqFBBbdq0Ud26da96rLi4OA0fPlwTJ07MtmD24sWL9dFHH+nee+9Vjx49VKVKFde2c+fOadu2bXrooYd07Ngx1axZUyVKlFC9evVUv359Pfjgg5nWsDh16pTWr1+vzZs3a9euXYqMjNSIESOyTMZcuW/FihVVvXp1NW7cWC+//LLKlSt31f2uZtSoUXrnnXdUtWpVhYeHu9VWiY2NVatWrfTXX3/J6XTKbDbriSee0FdffXVLLSWUFltmvv76a5UqVUpNmzaVJL311luaPXu2atWqpbFjx2Za+yUzCxYsUNeuXTV37lx17979qv1NJpPq16+vv/76K9t+VatW1f79+5WSkqKjR4+qePHirroVV2O323XgwAHX8lRZsVqtatiwofr27ashQ4Zc9c/OZrNp7dq1qlGjhkqWLKnly5erY8eO8vX1lcVikdlsvuY/f7vd7vYaOnSo3n333Ws6BgAAAG4vJDUAAABwTY4cOaLTp0+rVq1aOb6JiszZ7fYsC6ffSIZh3JSC1QsXLlSbNm1UoECBG35s3BqSkpLk6+vr6TAAAAAAF5IaAAAAAAAAAAAgT7h15n4DAAAAAAAAAABkg6QGAAAAAAAAAADIE0hqAAAAAAAAAACAPIGkBgAAAAAAAAAAyBNIagDAbWbMmDH6559/ctz/0qVLmbZfvHjxmsZ1Op1KSUlxvbdardq4cWOW/ZOSkhQfH6/k5GTZ7XbXKzk5WfHx8bLZbDp+/Liio6NltVpdr/Pnz2d6vO3bt2vevHmZbrPZbJo0aZL27t2b7TkEBwfr+++/z9A+f/58lS9fPtt9AQAAAAAAcPOR1ACA28hff/2lt956S+vXr8/xPt27d1fr1q2VnJzsalu9erVKliypffv25fg433zzjWrUqKEzZ85Ikj799FN16NBBcXFxmfafM2eOAgMD5evrK29vb9fL19dXgYGBmjx5spo0aaLixYurcOHCrlf16tUzPd4vv/yioUOHZrrN4XBo6NCh2rNnT7bnkJKSosDAQEmSYRhKSkqSJPn7+8vhcLjaExMTXe8l6dlnn5XJZLqmV/369bONBQAAAMgLfv/9d/3+++8Z2nfs2KHhw4df07F27typTz75RAkJCTne58CBA9q/f7/r/aVLlxQXF5fh4Sm73e72Hf5GSElJkc1mk2EYOd7H6XTm6PwGDhyoBQsW5Pi4SUlJOn78eI5f6R9IA4C8xsvTAQAAro/VatXx48fl7e0ts9ksk8mk8ePH66677lKjRo3cZiU4nU4lJyerZMmSKly4sKs9MTFR4eHh6tq1q3x8fFztTZs2VcmSJfXyyy9r5cqVV43FMAyNHTtWYWFhKlKkiCTpxRdf1JQpU/TOO+/o/fffz7BPt27d9Mgjj8jLy0v169fX8uXL9Z///EczZ85U1apVFRAQoAEDBshischischsNmvu3LkaNWpUpjGkJUQyk9ae/hzTrFq1StOnT9fChQvl7e2tfPnySZKOHj2qcuXKufU1mUyun8PDw9WyZUtJkpeXlzp27Kivv/7atX3FihVyOp1q3759hjHHjx+v8PDwTGMFAAAA8pJx48a5vtMnJiYqICBAJpNJUVFRGjt2rP7zn//orrvukpSaBHA6nSpQoECmx5o5c6YWLlyoTp06KSAgIEfjjxo1Sna7XfPnz5cktW3bVhs2bMi0b9GiRRUdHe3WtmvXLplMJnl5ZX+LzOFwKCEhQXXr1pXFYpEkffHFF+rTp0+O4rxSdomQEydOaNq0aSpevHiOj7d582Y1bdo0x/137Nih2rVr57g/ANxKSGoAQB61fPly9enTRz4+PjKbzUpOTlZSUpIKFCigRo0aufVNW9ZpxowZeu6551ztX331lRITE9WnTx+dPn1a0dHRrgRA7969denSJe3Zs0dmc+rEvqSkJNWoUcP1JT79cfbs2aMvv/zS1RYYGKgJEyaoZ8+eateunVq0aOG2T1BQkIKCgiRJZrNZBQsWlMViUcGCBbP88m42m93GTkhIcM3wuBZJSUkyDEN+fn6KjIzUP//8kyEhUrp0aZ05c0Z+fn76+eefNWTIEO3evdu1f9qMDik1qWE2m+Xn5+faPnToUBUtWlRt27Z1fX5ms1k+Pj7y8vLK8BkCAAAAec3Fixe1bt06ff3115o7d64GDhwoX19f1/ffAgUK6MEHH5SUehPf4XCodevW+v7777Vv3z4lJSW5vksnJibqiy++0Msvv+xaejaNw+GQzWZTvXr1MsTg6+vr9t36m2++kcPhcMVx4MABdejQQbVq1dKHH36YYf+uXbvq2LFjbtcUNptNCQkJCgkJcbXZ7XYlJCTozJkzCg4OliR17txZzZo1k5+fn9sDULNnz9bMmTO1adOmDOM5HA632eyxsbHy8vJyO48ZM2Yof/78eumllzLs73Q6Xdd36a9J0h7gOnz4sMqWLZthv/Tn5u/v77p2AYC8iKQGAORRzzzzjJ555hlJqV9M69evr3bt2um9997TiBEj1KRJE9dMgqxMnTpVRYsWVaNGjTRlyhS99tprGb7cTp06VVLqRUhycrJOnTrl+hIvSadOndLLL7+sXr16qU6dOm77Pv3001q0aJE6d+6s8PDwDEsueXt7uy5uypYtK4fD4eozdepU9e/fP0PM6S8WGjdurJ07d2a5/UoPP/yw6+fnnntOn376qSIjI+VwODRixAjZbDbNmjVLK1as0NixY12zWtIuUtIuGtJfPKSdR3qjRo3SwYMHdfDgQdfMD0l699139frrr0uS60IPAAAAyKs+/fRTJSQk6KGHHlJAQIBeeOGFHO/br18/bdy4UV5eXjKZTIqPj5eXl5c+/vhjffzxx2590x7gSkuCZKdEiRKun/ft26fHH39cTzzxhKZNm5bpg0URERFKTEyUv7+/q23y5MkaM2aMW2Ll4MGDCgsLc/vuHxwc7HZtlGb//v3q0KGDSpUqddXPoVatWjp69Gim29IeAstMw4YN9eeff7rep8V19uzZbBMWaUvsXsuSWQBwq+GOCgDcBvr06aMSJUro3XfflZQ6bXv79u3Z7rN48WLt2rXLdYP+5Zdfls1mU0xMTKavixcvKjEx0e1Lu8PhUM+ePRUYGKhJkyZlOs7cuXNVrVo1NW/eXHPnzs2wPSIiQsWLF9fx48dVpUoV/fPPP7r77ruznMmQ/sv3jz/+qBMnTujUqVMaNWqUKlasqFOnTmV4HTx40BXLyZMndfjwYY0dO1aStG3bNiUlJenHH3+U3W7Xxo0b9csvv+jChQuyWq2Ki4tzrZMbFxenuLg4xcbGKjo6Wna7XZJ7ImXp0qUaP368qlevrosXL8owDL3yyiuqV6+ehgwZku2fCQAAAJBXJCcnux6ASlsq6n//+59rBvOVL5PJ5FZLYs2aNUpMTNSlS5f0448/ys/PTxs3btSff/6p3r176+jRo65rkYSEBDkcDreERlJSkpxOp+u90+l0qxOxbds2NW3aVD169NCMGTOyvL7Yv3+/ypQpo7Vr12Z7ru3atdOTTz6ZYVvazIu016VLlxQeHq5mzZq5tae9rqyn8csvv+iff/7RsWPHdOrUKfXo0UOlSpXSkSNH9Ntvv2nGjBmZXuP89NNPbsdJe2jqnnvuUfHixbN8pc3iSEtuAEBexEwNAMjDEhIS9NJLL+mvv/7Sn3/+6fqi7uvr6/aFPyUlRcnJyfL395fZbJbNZtOwYcNUsGBBt+OtWLFCe/bscbv5vnHjRnXp0kUTJ07UE0884Wo3DEMvvPCC1q5dq9mzZysmJibLouCff/65XnrpJT399NOuqemhoaGuGC9evOj2ZJSUuqSTw+FwuzBJSUlxK+6X/smnoKAgWSwWFStWLMP4aXEFBwe7LW2VkJCgnTt3at26dbrnnnsUHByszz77TE2aNFHv3r01e/Zst+Nc+aTUgQMHVLFiRdf7mJgY9enTRxMnTtRff/2lBx98UB06dND333+v9evXX/MyWQAAAMCtasaMGTp9+rRbm7+/v5o2barffvvNrf348eMqXbp0pjMIjh8/ri5dumjGjBmqW7euVq1apffff1+vvfZatuNXqFBBJ06ccD1g9MUXX6hbt26aM2eOZs6cqWHDhumFF17QkCFD3GZcpC15m6Zy5cpq3ry5OnXqpC1btmS6dNOkSZN05MgRLVy4MMO2X3/9VQ899FCG9m7dumUad9myZXX48GHX+/TXE5s3b9ZXX32lRYsWqUyZMvrxxx81ceJE9e3bN9vPIr1//vlHZcqUuWq/q814AYBbGTM1ACAPmzx5sj777DPt27dPBQsWlMlkkslk0pEjRzR48GDXex8fHwUGBurvv/+WJL3xxhs6c+aMhg0b5na8yMhIvf3224qPj3e1bd++XVFRURmWlvrkk080Z84czZkzR6NHj1a5cuVUunTpTF9VqlTRq6++qgkTJig4OFiFChWSlPo0UVRUlAzDyFAs0Gw2a+LEifL393e9nn/++Rv6RFF8fLx69OiR4dwk6eOPP1ZKSooMw3C9VqxYoZIlS8rpdCo+Pl7ly5d32yc4OFg7d+7U4MGD1a9fP+3Zs0cjR47UU0895bYeLwAAAJCXnTlzRiNHjsyw3FRSUpK2bNmiu+++2+3VunVrSXJ7QEmS9uzZo2bNmunpp5/W008/LUmuWndpN90Nw1BSUlKGGQ5btmyR1WpV9+7d1aVLF509e1ZTp05V165d9eKLLyohIUEffvihChcu7PZq3LhxhvOZM2eOgoKC1KVLF9ds7DQbNmzQO++8ozFjxujuu+/OsG9avGnXDvfdd5/mz5/vuoZo0aKF5syZI8MwNGPGDFftiyudPn1ajz/+uJ577jk9+uijklKXlLqy9l9W0uI+e/asoqOjr/o6fvx4hs8UAPIK0rIAkIf16tVLAQEBqlOnjkqWLCk/Pz9ZLBY1btxYzz77rPr06SMpdbp0cnKySpcuLUlq3769atasmaH+RLdu3TRs2DAtXbpUXbt2lZR6sVC9enVVqlTJre8LL7ygBg0aqF69emrVqpW8vLw0fvx4ffPNN251LrZt26ZmzZqpXLlymT7BtGDBAldSISQkROPHj9fZs2dlMpnk7++vZs2aZXjSKyv79u3LtqbGlQoXLqxPP/3Ure27777T6NGjtXDhQsXFxbk9wXThwgU5nU5FR0crKSkpwxNQBw4c0KJFi/Tjjz9q9+7dGjFihKpWrarhw4dr+vTpeuihh9SmTZscxwcAAADcii5evKjKlSvrxRdfdC1BJUlPPPGEmjZtmuV+Vy4B1bFjRx06dEgTJkzQhAkT3LZd+VBQ7dq1tWPHDtf7tBnaPj4+MpvNCg0NlSS9/fbbGj16tPr06aMaNWrotddeU/ny5bV582YtXrxYv/zyS4a48uXLpylTpujrr7/O8BDV119/rVatWunVV1/N9JyudTZ2Zv0vXLigDh06KCoqSrNmzdKsWbPctl95jTNr1iz17t3bre3cuXOSpHvvvTfHsXz99deu6z4AyEtIagBAHla8eHENGjQoQ7vFYlFQUFCmSzFJUosWLSSlLguVXtGiRfXQQw/p22+/dX253bRpk9q1a5fhGCaTSfXq1ZMk18yLAwcOqGbNmm6FtC9cuCCTyeRKqFx5jAsXLqhHjx6SpG+//Vbbt2/X6tWrXedxLSpWrKh169ZlaE9ISFCFChUy3efChQtasWKF5s+fr9jYWG3cuFH9+/fXZ599lmUNjLTig5cuXXI7V5PJpMWLF6tr166aO3euq1j79OnTlZCQoLlz5+b4SSsAAADgVlWpUiVt2LBBp06dkiQlJiYqICAgR9/fg4ODXctBTZ48WVarVTVr1lTBggXl5eWlLVu26LHHHtO+ffuUP39+10yNtJoRV1OrVi1FR0dry5YtGjp0qHbu3Ck/Pz/VqVNHCxcudH1/T0pK0u7du+Xr6yuLxaLKlStrxIgROnbsmM6cOSOHw6G9e/fqpZdeUnJysvbt2yeHw6Hk5GQVKlRIYWFhWcbQrVs3de/eXVJqrY+0nzNz4sQJtW/fXhcuXFD9+vVVr149DR8+XJI0f/58ffLJJ24PeTVo0CDTawqr1SovL68cf1Ymk0n58uW7aj8AuBWR1ACAPMgwDMXHx8vHxyfL6ctXcjqdSk5OltPpdBXyy0z79u31xhtvKCUlRbGxsYqMjNTkyZOvevz4+HitXr1aI0aMcGs/fvy4ChcunOkXb8Mw9O6776pq1aqSpJIlS6pkyZIZjpFTV6upcSW73a46dero3Llzevrpp+Xv76/3339fTZo0UXJysvr16+cqaihJK1euVO/evRUVFaWkpKQMdUAqVqyojRs3SkqdWr9w4UJ9+OGHatGihfbt2+cqlD5mzJjrOj8AAADgVpE+gZH285EjR9zq3l0pIiJCDz74oOt927ZtM/RJqzdRpEgRBQcHX1NMDodDFotFI0eOVMmSJdW+fXsNHDhQ999/v7y8vBQfH6/8+fNLSr1OadiwoavuYHpJSUlKSkpSo0aN3NrtdruSk5M1YMAAffjhh1nG8dVXX6lLly6SpJYtW2bZ7+jRo7rnnnsUEBCgNWvWaMiQIQoMDHR9hmmJnvSfqcViyXS2x4EDB1S6dGmZzWY1adJEGzZsyNDnvffe09ChQ12zUbK7LgSAWxk1NQAgDzp9+rSCgoLk6+vrqpuR/nXw4EG98sorbm0Wi0X+/v6ZriGb3kMPPaRLly5p/fr1Wrt2rXx9fXX//fdfNaYJEybIZrPpqaeecms/ceJEprM00tx///0qVqyY22vnzp0yDCNnH8a/4OXlpW+++UZHjx7Vxx9/7HZx4OPjozlz5rguRtIzm80ZEhrpHT58WEWKFNH//vc/9ejRQwcPHsy04CAAAABwO/Dy8lJkZKQ2bdqk4sWLy8/PT15eXq6Xn5+fSpQooQsXLmjDhg1KTk5WQkJChvoV2bHb7UpISFBycnKGbadOndLQoUPVunVrLViwQJ988ommTZum5ORkffvtt+rYsaMkuSU1KlSo4HqQKyYmxu317rvvKiQkJEN7XFyckpOTs01oSKkzNdLOfc2aNVn2K1OmjCZOnKgNGzZkObM8pzZs2KDq1atLSi3Y3r9/fx07dsz1atCggSv5lJbUYKYGgLyKmRoAkAcVLlxYBw4ckK+vr9tMgjQNGjRQ79693Qr3ORwO2Wy2LGtO2Gw2+fr6qkqVKvr999/VuHFj9e3bV40bN5afn5+k1NkeDocjw5NB06ZN09ixYzVx4kQVLlzYbdv+/fuzTGo4HA6tW7fONVMjTf369TMUEUyzdOlSSdIjjzzi1u50OmW323X8+PEM+6QVwMssUXLPPfdkOo4kVatWTS+++KJGjx6typUrZ9nvyliLFy+ur776St9884169Oghi8Wi9evXuy4y0uIFAAAAbgdms1lVq1ZVhQoV1K5dO9c1StpyUrVr15bNZpOPj48sFovGjx+v//73v9kes2DBgpm2f/jhhxo0aJCOHz+uH374QWvWrNHx48dVoEAB+fv7q3v37nr33XfVtm1bjRo1Sna73bX8U0JCgooXL37Dz/9KOZ2pIclVIF3K/HrlSpldR5w7d05r167V2LFjJaUuLRUUFOQ2w8PHx8d1LchMDQB5HUkNAMiDLBaLKlasmG2fgIAAV7G8rDgcDhmGIZvNlu3Mg/SJkDfffNO1fNKBAwc0ZswYffnllxo2bJgGDx4sKfXL+MSJE3Xs2DEtXbpUo0ePznL8atWqZbnNbDbr2LFjOnv2rIKCguRwOPTJJ58oOTk5Q1LD4XDo4MGD2c4Kyeypruw0b95cXbp00cWLF7PtZ7fblZiY6JZQqVGjhqsw4U8//aQCBQq4tsfGxl7TU2kAAADArSjtJrxhGDKZTPL29s50aSSTyeR2vfH888/rySeflK+vb4bldP/88089/PDDOnjwoGtWhZT6XT4pKUkFCxZUfHy86tWrJ7PZrL59++qFF15QsWLFNHnyZD3yyCPq06ePVq1apTFjxmjy5MkKCgqS5D5T41Z0ZZHy9L744gtt2bJF0dHRGR4kmzx5sgzD0JNPPikptb5GZsXXH330UUlSTEyMJGZqAMi7SGoAwG3I4XBkOdMhvZSUFDmdTvn4+Oivv/5SQEBAtkXl7Ha7ChQoICn1Kadu3bopOjpaixYtck3pllIvWo4dO6aff/5ZQ4YMybSYuWEYstvt2rlzZ4ZZEPfdd5+Sk5PVsGFDHTt2TEWKFHFt8/Hx0ZIlSzIcz2QyqUGDBtq8eXOGbXFxcQoKCrpqUiM5OVkpKSlux/z66691/vx5vffee1q/fn2mX/wdDod++umnbBMqaQmfNA0aNMg2FgAAAOBWl3YTPjk52a2G3pEjR2S1WuV0OjO9vggJCVFISEimx0xLQBQsWDDL2RqSFB4erkqVKrklSwYNGiSn06n3339fb775pp555hn1799f0dHRio2N1c6dO9WmTZurnpfT6czxcrhpMyfSJ3M2bNigrl27ut6vXr1avXr1kqQsH+qS5EoMZRbHqVOntGDBAvXu3VtNmzZ19dm+fbsmTZqkHj16uIqXr1+/PtMZHVarVa+99pr++usv+fv7Z1v/BABuZSQ1AOA2lFbY7mouXrwom80ms9ms+vXrX9MYAQEBWrFihfz8/DK90f/RRx9lu7/JZMryQmHr1q1uMcbHx7ve58+fP9Pi6K+++qpeffXVTI8XGBiYo4uSrD63ggULatq0acqfP7/GjRuXYbvdblenTp303XffXXUMKbVQ+KJFi3LUFwAAALhVpT0QdGVS46uvvtLw4cNVvnz5bJdxzUzaw1lXe0irVq1amba/+uqr+vDDD9W/f39NmTJFkjRw4EB9++23ypcvX46SGsnJyTme5Z12/RATE+NWPD0zs2fPdsWUmRUrVri9dzgcrs/4tdde0+uvv55hn6JFi6pfv3564403XG1ZLSsVGBioJUuWyNvbW9OnT3ctMwwAeY3JyI1KrAAA5HF2u11eXpk/C2C1WmUYRoZp4AAAAMCd6Pz58zp//rwqVKiQZU2/rKxYsULt2rXT8ePHVbJkyWse+8yZM9q+fbtat27taouIiNChQ4fUtGlTBQcHX/UYo0eP1pgxY3L0oNjNNHnyZE2YMEGnTp3yaBwAcKshqQEAAAAAAAAAAPKErBdOBwAAAAAAAAAAuIWQ1AAAAAAAAAAAAHkCSQ0AAAAAAAAAAJAnkNQAAAAAAAAAAAB5gpenA8jLnE6nTp48qaCgIJlMJk+HAwAAAFyVYRi6dOmSSpQoIbOZZ5wAAAAA5C0kNf6FkydPqnTp0p4OAwAAALhmx44dU6lSpTwdBgAAAABcE5Ia/0JQUJCk1AvC/PnzezgaAAAA4OpiY2NVunRp13dZAAAAAMhLSGr8C2lLTuXPn5+kBgAAAPIUlk8FAAAAkBexiC4AAAAAAAAAAMgTSGoAAAAAAAAAAIA8geWnAAAAANyynE6nkpOTPR1GrvL29pbFYvF0GAAAALclh8OhlJQUT4dx28qN77IkNQAAAADckpKTk3X48GE5nU5Ph5LrgoODVaxYMWqfAAAA3CCGYSg6OloxMTGeDuW2d7O/y5LUAAAAAHDLMQxDp06dksViUenSpWU23xkr5xqGoYSEBJ05c0aSVLx4cQ9HBAAAcHtIS2gUKVJEAQEBPDxyE+TWd1mSGgAAAABuOXa7XQkJCSpRooQCAgI8HU6u8vf3lySdOXNGRYoUYSkqAACAf8nhcLgSGoUKFfJ0OLe13Pgue2c87gQAAAAgT3E4HJIkHx8fD0fiGWmJHNZ7BgAA+PfSvlPdaQ/LeMrN/i5LUgMAAADALetOXRbgTj1vAACAm4nvWLnjZn/OJDUAAAAAAAAAALjF2e12T4dwS6CmBgAAAIDbms1mk5+fX7Z9HnzwQY0YMUJNmzaVzWaTxWKRt7e3Wx/DMBQTE6OCBQvezHABAACQi0wjc3f2hvGOcV37JSUl6cEHH1S7du305ptv3uCo8hZmagAAAAC4bW3dulVly5aV1WrNsk9ycrI2bNigKlWqSJKeffZZVa5cWfnz51eJEiUUEhKi0NBQVahQQQ0bNsyt0AEAAAAXX19fjR07VpMnT9bgwYM9HY5HMVMDAAAAwG3j0qVLMgxD3t7eMplMmjJlijp06KDAwEDZbDZJktPplM1mU0hIiObNm6e5c+fKy8tL/fv3l9ls1rfffitJ6tmzpzp37qwtW7YoODhYgwYNyjDeiBEjtGPHDi1evNjV1rx5c61du1Z+fn6qUaOG3n77bT388MO5cfoAAAC4jTVv3lyrV69W48aN1aBBA3Xt2jXLvhaLRQUKFJDZnPm8hoSEBD3xxBP6/PPPb1K0Nw9JDQAAAAC3jQEDBui7776TxWKR3W5XSkqKvLy8NHv2bBUoUEBS6lrENptNdrtd9evX1++//64CBQqoV69eSkxMvCFxjBs3Tp07d9aXX36pjh07as2aNWratOkNOTYAAADuXLVq1VKrVq302muvqXPnzhmWTE3j6+urzZs3q2LFipluHzFihE6cOHEzQ71pWH4KAAAAwG3jyy+/VEJCgk6fPq3atWtryZIlWrlypYoWLaqYmBjFxMQoLi7OVWSxatWqunDhgqpUqaIFCxboP//5j/r06aOKFStq0aJFev755zV16lSNHTtWFStW1H/+858cxeHv769KlSpp9OjRevzxxzVlypSbedoAAAC4Q0RHR2v16tXy8vLSV199lWU/Hx+fqx7LYrHcyNByDUkNAAAAALeVhIQE9ejRQ8OHD1f79u3l5+cnX19f1/aUlBQlJCRISl2K6vfff1fTpk119uxZSdLZs2f16aef6oEHHtDixYs1ePBgjRs3Tr/99lu2tTmy0qZNG/3111835uQAAABwR3v33Xf12GOPaeDAgZo6daqnw/EIlp8CAAAAcFtp0qSJtm/frkWLFsnLy0smk0kpKSny8/OTlFoYvHLlytq7d69WrFihokWLqlixYjKbzUpMTHQ9sRYTEyMfHx+dOXNG5cuXl6Qs1yTOTvHixXXmzJkbd4IAAAC4I+3du1czZ87UH3/8oXLlyuntt9/WihUr1LZtW0+HlquYqQEAAADgtjJ16lTt3LlTycnJSklJ0R9//KEyZcrIZrPJZrPJ6XQqIiJCkrRlyxYdPXpUbdq00a+//qrKlSvrwoULkqTDhw9r2rRpOnz4sH755ZfrjsdkMskwjBtybgAAALgzORwO9e7dWz179lSdOnUUHBysfv36adiwYTesLlxeQVIDAAAAwG2lSZMmqlWrVpZFEyXJyyt10vrw4cN18eJF/fzzz3rggQd07NgxhYSE6OLFi0pISNCJEye0YcMGrVq1SqdOnbqueE6fPq2iRYte174AAACAJA0dOlTHjh3Tu+++62p7/fXXFR0dreeee04Oh8OD0eUulp/CVUVFRV3X2sEAbp6kpCS3tcEBADdOaGiowsLCPB0GroPNZtPp06fl7e3ttkzUuXPn5HA4FB0d7WpzOp1KTk5WiRIlZLfbdejQIUVFRWnYsGG6ePGifvvtNzVr1kxDhw7VgAED1LZtW02fPv264lq1apUaN278r88PAAAAdx7DMPT2229r9uzZWr9+vYKDg13bChYsqDlz5uixxx7TxYsX9fnnn6tw4cKeCzaXkNRAtqKiolSlajXZEhM8HQqAdMxms5xOp6fDAIDbUkBAgCIjI0ls5EFbt25V8+bN5evr65qJIaVO1Y+Pj1fVqlVdbXa7XUlJSZo0aZLGjRunu+66S2azWY888oj++ecfXbhwQZ07d9asWbPUqVMnde/eXUePHtVbb72Vo1gSExP1zz//6Ouvv9a3336r9evX3/DzBQAAwL9nvHPrLhN69OhR9evXT+vXr9eSJUtUs2bNDH06dOigL7/8Us8884xq166t3bt3q2DBgkpJSdE999yTZU24hIQEdevW7Wafwk1BUgPZslqtsiUmqFCHIfIuVNrT4QCQlHhoiy6um6eXR3ysUmUreTocALitHD9yQFNGDJDVaiWpkQfdd999SklJydC+efNmPf744zp69GiGbQ6HQ/3791dERITefPNNNWnSRB9++KF69uyp5s2bq3nz5jKbzQoKCtLp06dlMplyFMsbb7yhUaNGqX79+lq1apXq1av3r88PAAAAd5agoCAlJSVp3bp1ql27dpb9nnrqKZUuXVpHjx5VwYIFJaWu8rFz505VrFgx031GjBihw4cP35S4bzaSGsgR70Kl5Vss878AAHJXyrljkqRSZSupQpVaHo4GAIBbX1JSkmw2W6bbLBaLLBaLUlJSXAmRpKQk1/bixYtLksaMGaMvvvhCw4YNc9t/xIgRGY7522+/3ZjAAQAAcEcLCQnR6tWrc9T3/vvv1/333+96b7fbs+2f2ffYvIKkBgAAAIDb2v3336/Tp09n2+eee+5ReHi4JOnHH3/MsH348OEaPnz4TYkPAAAAQM5lvqAWAAAAAAAAAADALYakBgAAAAAAAAAAyBNIagAAAAAAAAAAgDyBpAYAAAAAAAAAAMgTSGoAAAAAAAAAAHCbOnv2rBYvXqzY2FhPh3JDeHk6AAAAAADIqaioKFmt1lwbLzQ0VGFhYbk2HgAAAHLXrf798tKlSzIMQ97e3jKZTFn28/b2lsViyXTbnj171LFjR+3bt0/58+fPdjwvLy+VKFFCZnPqfIiTJ08qJCREfn5+kqTY2Fi1aNFC3377bY7P4UYjqQEAAAAgT4iKilKVqtVkS0zItTH9/AO0b28kiQ0AAIDbUFRUlKpVqaIEmy3Xxgzw81Pkvn05/n45ZMgQzZ07V97e3q5Ew5Xi4uI0ZcoUDRgwINPtackOHx+fDNsMw5AkV8LE19dX27ZtU2hoqCSpRo0amjx5slq2bClJmjRpknbs2JGj2G8WkhoAAAAA8gSr1SpbYoIKdRgi70Klb/p4KeeO6dyP78tqtV5TUmP16tVq2bKlTpw4oRIlSrjaz507p/r16+vXX39V2bJlb0LEAAAAuBZWq1UJNpvmSaqWC+NFSupus13T98uZM2dq5syZ2fZp0qSJayZFdipWrJihzeFw6K+//lL9+vUlKcvESXpeXp5NK5DUAAAAAJCneBcqLd9iGS/IbhWrVq2SJIWHh+uZZ56RlHrB/PDDD+vIkSMejAwAAACZqSaprqeDyMKlS5c0e/ZsPf300woJCcmyX1ZLT6X3zz//ZHi4Jjk52S1JYbFYdP/997uO988//6hPnz7Kly+fpNQHdVq3bn0dZ3LjUCgcAAAAAG6g8PBwNW/eXOHh4a62Ll26qEuXLh6MCgAAAHlRQkKCXnnlFZ0/f/6mHN/Hx8dtdoZhGFq3bp0iIiIUERGhihUratasWa73Q4YMuSlxXAtmagAAAADADXL27Fnt3LlTS5YsUe/evWUYhkwmk2bOnKny5ctr0KBBng4RAAAAeYivr68k6Z577slyaaiLFy+qZ8+eN2Q8h8NxQ45zM5HUAAAAAIAbJDw8XJUrV1bLli114cIF7dq1S7Vq1VL58uU9HRoAAADysEOHDik4ODjTbU2aNFFSUpLr/Z9//ql7773XbUkqi8XiVlPD6XSqZ8+e+uyzz9yOZbPZVLduXVcC5eTJk+revburZkdsbKweeeSRG3Va14WkBgAAAADcIOHh4WrUqJH8/PxUp04drVq1SrVq1fJ0WAAAALiNLV261K1QeNrPMTExCgwMzHSfnj17KigoyK3twoULkqSDBw/K29tbklSjRg1NnjxZLVu2lCRNmjRJERERN/wcrgU1NQAAAADgBgkPD9f8+fMVHBysbdu2udXVAAAAAG6GkJAQ+fv7X/N+JpPJ7f2uXbtUrVo1V0LjVsVMDQAAAAC4Afbs2aMTJ07ozz//VNGiRbVu3Tq98MILSkpKcq2FDAAAgFtP5G0wzpgxY7R//37NnTv3uo+xePFitW7d2q3NMAwZhuF6b7fbs6ztkVtIagAAAADIU1LOHbslx1m1apUqVqyohg0bSpJCQ0P13HPPaf369WrRosXNCBEAAAD/QmhoqAL8/NTdZsu1MQP8/BQaGprj/mkPxyxbtkxt2rTJMLtCks6fP69vv/3WtexpWhIiu3FSUlI0YMAA1/uzZ89qzpw5Wrt2rVs/u92u5ORkSdKbb76pL774QgMHDsxx/DcDSQ0AAAAAeUJoaKj8/AN07sf3c21MP/+AHF90hoeH68EHH3S9DwwMVKNGjbRq1SqSGgAAALegsLAwRe7bJ6vVmmtjhoaGKiwsLMf9/f399dJLL+mVV15Rv379suxXvnx5vf3225KkhIQESZLVas22pkZcXJzrfVxcnP773/9mqAc3a9YsVa1aVZJ07733qmHDhmrfvn2O478ZSGoAAAAAyBPCwsK0b2/kLXvRuXz58gxtv//+u9v79FP3AQAA4HlhYWHXlGTwhKlTp2rq1Kk57n/fffdd9Xvn559/7va+XLlyGjZsWIZ+TZs2df3coUOHHMdwM5HUAAAAAJBn5IWLTgAAAAA3j2cregAAAAAAAAAAAOQQSQ0AAAAAAAAAAJAnkNQAAAAAAAAAAAB5AkkNAAAAAAAAAACQJ5DUAAAAAAAAAAAAeYKXpwMAAAAAgJyKioqS1WrNtfFCQ0MVFhaWa+MBAAAAOdG9e3c1a9ZMffr0ybLP5MmTFRoaqu7duyspKUlms1leXl4ymUy5GOmNR1IDAAAAQJ4QFRWlatWqKSEhIdfGDAgIUGRkJIkNAACA21RefWimQoUKWrFiRbZJjSJFiqh///5q1qyZ3n//fU2ZMiXTfnPmzFHPnj3/dUy5haQGAAAAgDzBarUqISFBL4/4WKXKVrrp4x0/ckBTRgyQ1WrN8YXn559/rl69eslsNqtkyZLq0qWLxowZIx8fH7d+bdq0UZcuXfLUxSMAAMDtJioqSlWrVVViQmKujekf4K+9kXuvKbHx5JNP6vvvv890m5eX+y3+vn37atq0aZKkLl26aMGCBfL29ta4ceM0ZswYmc1mmc3/X5WiVatW8vb2vo4z8RySGgAAAADylFJlK6lClVqeDiNLNWrU0C+//KI///xT/fv31/nz5/Xpp5+6tn/11Vf6+eef1aVLFw9GCQAAAKvVqsSERHX/pLuKVi5608c7vf+05r0w75oempEki8Wi4cOHa8SIEYqMjFSlSpVcyYyUlBRXUqJnz56yWCySpOeff16PP/64li5d6jrO6NGjVb9+fbVt29bVZjabXfvkFSQ1AAAAAOAGslgsKlq0qB599FH5+fmpQ4cOeu+99xQSEqLz589ryJAhqlKliqfDBAAAwGVFKxdV6dqlPR1Glho3bqxSpUpp69atatmypXr37q2JEydKklq3bq2QkBCNHTtWjz/+uCtB8ffff6t58+Zux/nrr79UuHDh3A7/hjNfvQsAAAAA4Hq0aNFCJpNJO3bskCQNGTJEHTt2VKNGjTwbGAAAAPKMF198UTabTc2bN9dTTz2l8ePHu7bNnj1bsbGxqlGjhlavXq37779fkuTn5yez2axnn31WlSpVUtWqVfXrr79q5MiRqlq1qipUqKB58+Z56pT+FZIaAAAAAHCTeHl5KTQ0VGfOnNGvv/6q1atXa8KECZ4OCwAAAHlIly5d1K1bN40cOVIff/yx23JR5cqV06pVqzRlyhRNnz5dgwYNctt35MiR+vHHHzVkyBDFxcVp0KBBWrlypVasWKH27dvn8pncGCw/BQAAAAA3kclkkmEYeuGFFzRjxgzlz5/f0yEBAAAgD3n44YfVuXNntWnTRg6HI0MNDLvdrq5du6pWrVoqWbKk27bSpUvL6XSqR48eypcvnwzD0PPPP6+vvvpKBQsWzM3TuGGYqQEAAAAAN4nD4ZDVatXUqVPVoEGDPPs0HAAAADynW7du2rRpk4oUKaLQ0FCFhobKz89P/v7+rvfFihVTdHS0ypUrl2H/8ePHKzg4WC1btlRoaKjKlSunNm3aKCEhwQNn8+8xUwMAAAAAbpK1a9fKZDIpOjpau3btUnBwsCQpISFB33zzjTZv3qzp06d7NkgAAADc8t577z1XcXBJ6tmzp4KDgzV58mRXm2EYGfabP3++PvzwQ23dulUDBw6UJE2bNk2NGjXSe++9d9PjvhlIagAAAADIU44fOXBLj+NwOHT69Gn99ddf6t+/vwYMGKBXXnlFdrvd1efVV19Vo0aN1LNnzxsULQAAAG5nJpPpmvvExcVpwoQJ+u677xQWFqbk5GQ5HA55e3tr0aJFKlq0qH777bebFPHNQ1IDAAAAQJ4QGhqqgIAATRkxINfGDAgIUGho6DXtExERoRIlSqhMmTLq27evXn/9dZnN7iv/BgYGupYKAAAAgGed3n/6lh3HMIwcJTSu3CcxMVGBgYHavXu3fHx8JMntO2nhwoV1/vx5nTt3zrU9r7hlkho2m01+fn456rto0SI9/PDD8vb2liQdOXJEVqtV9evXv5khAnlK4wqF9HWfRrpn7C86cynJ1R4c4K1lLzZR11l/6viFRA9GCOB2E1bYT/UqFEj98pTs1PFzNu05FqcrZ782rhqs4+dsijpr80ygAPKssLAwRUZGymq15tqYoaGhCgsLy3H/nj175mj2xeeff379QQEAAOCGCA0NlX+Av+a9MC/XxvQP8L+mB1s2bNigFi1aKCAgwK1AeFxcnEwmk+bN+//YnU6nEhMT9dFHH+nSpUuS5Jaw+PHHH10/nzhxQpUrV1ZwcLDq1q37b04p190SSY2tW7eqffv2ioiIuOof6N9//61OnTpp/fr1uu+++yRJS5cu1UcffeSWdQLudE0rFZYk3V8pVN9vOyFJKhjgrdnPNFDpkABPhgbgNnYxIUUbImMUEuit2uWC5ONl1vZDsa7tpQr5qWiwr46fI6EB4PqEhYVdU5IBAAAAyEpYWJj2Ru69pR+aadiwoaxWq/z9/eXllf3tfIfDIZvNJrPZrN69e2fbt1KlStqyZYtq1KghX1/fHMdzK/BIUuPSpUsyDEPe3t4ymUyaMmWKOnTooMDAQNlsqTc5nE6nbDabQkJC3Pb95ptvVK9ePTVu3Ng19aZ///5atWqVDhw4oOrVq0u6tmk5GzduVM+ePbVv374be6KABzWpFKqNB8+pSaXCrqTGR13ratnfJ1W3TEEPRwfgdmUYUlKKU6cuJMnhNHRvlWBFHL2kFIchb4tJNcsE6lKi/eoHAgAAAAAgF9zqD814e3u7Viy6GovFonz58uX42PXq1bvesDzKI0mNAQMG6LvvvpPFYpHdbldKSoq8vLw0e/ZsFShQQJJkt9tls9nciuklJydr1qxZeuWVV7Rnzx7VqVNHQUFBruRFs2bNJKUmROrVq6fw8PCrxrJt2zZ17Ngxx0tfAXlBSD4fVSueX32+3KIJnWq62v/7w986dj5R7zxc3YPRAbhTnL2YLEkqkM9L1tgU1SwTpJMXkmQxX9taoAAAAAAAAGnMV+9y43355ZdKSEjQ6dOnVbt2bS1ZskQrV65U0aJFFRMTo5iYGMXFxbklNCRp5syZOnPmjIKDg1W9enUlJyfr3LlzslqtrtfRo0d1/vz5HCU04uPj1bFjR/Xv3z9HcSclJSk2NtbtBdyKmlQM1WFrvDb8Y1V+f29VLRYkSTp2nhoaAHKPISnJ7pSvt1mh+b1VuICPdkfFeTosAAAAAMAdyriy6CNuipv9OXskqSFJCQkJ6tGjh4YPH6727dvLz8/Pbe2ulJQUJSQkuN5brVaNGjVKZcuWdbUtW7ZMb775put9YmKiChYsqG+//TZHMXh7e+uPP/5Q06ZNc9T/3XffVYECBVyv0qVL52g/ILfdXylU26MuKMnu1J6Tsbr/cn0NAPAEk0yqUy6/dhyOld3BF0gAAAAAQO5KW74p/f1m3Dxpn3NOl826Vh4rFN6kSRNt375dixYtkpeXl0wmk1JSUlzLQCUnJ6ty5crau3evJOmTTz5Ro0aN3GpsFCxYUNOnT9c777wjHx8fRUREyOl0qkWLFjmKwcfHRyVLltSBAwdy1P+///2vBg8e7HofGxtLYgO3pCaVQhUS4KPW1YvJz9uiSza7Zq075OmwANyBfLzMqlDMXxfiU3Q6JtnT4QAAAAAA7kAWi0XBwcE6c+aMJCkgICDH9ZiRc4ZhKCEhwbXaksViuSnjeCypMXXqVOXPn1/VqlWTt7e3tmzZos6dO+vIkSOuPumXnxo0aJAuXryoN954w9V23333KX/+/Prll1/Url07bdmyRQ0bNsxQXPxG8fX1zXOV4HHnqVgkUMUL+OuxjzfIGpekBmVDNK5jTflYzEp2OD0dHoA7SGj+1CcyfL0tyh/gpfb1U2eNeZlNKhnip4L5vLXzyCVPhgggD4qKipLVas218UJDQ2/pwpEAAADImWLFikmSK7GBmyc4ONj1ed8MHp2pcTVeXv8fXr58+TJUbjeZTHr44Ye1fPlytWvXTps3b87xLA3gdtW0Umo9jR3HYiRJ5+OjNaFTLdUvW1B/HDzn2eAA3PZMJsnX26yC+bxUu1x+HYpO0D/RCUpfG7xGWJDOx6Uo6ix1fgBcm6ioKFWrWkUJibZcGzPA30+Re/eR2AAAAMjjTCaTihcvriJFiiglJcXT4dy2vL29b9oMjTS5ntSw2Ww6ffq0vL29ZTb/f0mPc+fOyeFwKDo62tXmdDqVnJysEiVKyMfHJ9PjPfjggxo2bJgkad26dfr0009v7gkAt7gmlQpr48H/f3oxIdmh7ccuqGmlwiQ1ANx0BQK81bZuqBKSHDp8OkH7T2Zcr9TuNJRsdyrZTn0NANfGarUqIdGmeR39Va3wzS8PGHnWqe4/JMpqteY4qfH555+rV69eklKXu61Vq5amT5+uBg0aaObMmXrnnXdktVr1wAMP6IsvvlDx4sVv5ikAAADgChaL5abfdMfNletJja1bt6p58+by9fV1m4nhcDgUHx+vqlWrutrsdruSkpK0ZcsW1a5d2+04TqdTZrNZLVq00JQpU3TkyBEdP35cjRo1yrVzAW5Fz37+V4a2Jz/50+192deX51Y4AO4gUWdtijp79aentx2MzYVoANzOqhU2q27xW/dCtEaNGlq3bp1SUlL08ccfq3Pnzvrqq6/01ltv6auvvlLVqlX11FNP6dVXX9VXX33l6XABAACAPCXXkxr33XdfptN7Nm/erMcff1xHjx7Ndv+UlBQ5nU5169ZN33zzjaugi2EYcjqdCgwMlJSa9Dh06JDKli17w88BAAAAALKSVohSkp5//nmNHDlSGzZs0IwZM9SyZUtJUq9evTR+/HgPRgkAAADkTR6rqXGlpKQk2WxXf7ozNjZWKSkp+vLLL/XVV1+5LWGVnt1uz/E0oubNm7sVKAcAAACAG+Hbb79ViRIl9Oqrr7pdn+zbt08VK1b0YGQAAABA3nTLJDXuv/9+nT59+qr9li1blqPjpV/aCgAAAAByy65duxQcHKyUlBQ5HA6tXLnSLaFx7tw5ffLJJ5o3b54HowQAAADypptfXQ8AAAAA7iBVqlTRjh079Ndff+m5555T7969FR8f79rev39/NW7cWO3bt/dglAAAAEDexHQGAAAAALiBfHx8XLX9pk2bpgIFCig8PFyPPfaYPvvsM/3+++/asWOHR2MEAAAA8iqSGgAAAABwExmGIbvdrs2bN2vQoEFatmyZihYt6umwAAAAgDyJpAYAAACAPCXyrPOWHsfhcCgmJkaXLl3S9OnTlZSUpAYNGuiee+7Ra6+9pnr16ikuLk6SFBgYeCNDBgAAAG57JDUAAAAA5AmhoaEK8PdT9x8Sc23MAH8/hYaGXtM+ERERKliwoHx9fVW9enUtWrRIP/zwg86cOaPhw4dr+PDhrr6GYdzokAEAAIDbGkkNAAAAAHlCWFiYIvfuk9VqzbUxQ0NDFRYWluP+PXv2VM+ePTPdNmjQoBsTFIBbVlRUVK7+GwUAd5Jr/V6G2xdJDQAAAAB5RlhYGBezAG5JUVFRqlalihJsNk+HAgC3pQA/P0Xu28d3QZDUAAAAAAAA+LesVqsSbDbNk1TN08EAwG0mUlJ3m01Wq5WkBkhqAAAAAAAA3CjVJNX1dBAAANzGzJ4OAAAAAAAAAAAAICdIagAAAAAAAAAAgDyBpAYAAAAAAAAAAMgTqKkBAAAAIM+IioqS1WrNtfFCQ0MpRgkAAADcQkhqAAAAAMgToqKiVK1aVSUkJObamAEB/oqM3HvDEhvnzp3Tvn37VLlyZYWGht6QYwIAAAB3EpIaAAAAAPIEq9WqhIREzXv9YVULK3TTx4uMOqfu45fJarVeU1IjJiZGvXv31ooVK1SlShXNnDlT9evX14IFC9SvXz+VLVtW+/bt02effaYuXbrcxDMAAAAAbj8kNQAAAADkKdXCCqlupWKeDiNLvXr1ks1m044dOxQeHq5HHnlEW7du1UsvvaR169apRo0amjt3rl577TWSGgAAAMA1IqkBAAAAADfI4cOHtWTJEp04cULFixdXpUqVNGHCBK1atUqTJ09WjRo1JEm1a9fWhQsXPBwtAAAAkPeQ1AAAAACAG2TDhg0qX768ihcv7mobMGCAKlSooCZNmkiSUlJSNGnSJP3nP//xVJgAAABAnkVSAwAAAABukBMnTqho0aJubcOGDXP9vHPnTj3wwAPy8fHR3r17czs8AAAAIM8zezoAAAAAALhdpKSkyGKxZLm9Vq1aWr16tapXr65evXrlYmQAAADA7YGkBgAAAADcIMHBwRlqZTRu3FgzZsyQJJlMJtWpU0eff/65lixZQl0NAAAA4BqR1AAAAACAG6ROnTrav3+/YmNjXW2HDx9WWFiYhg4d6mrz8kpdCdhs5pIMAAAAuBbU1AAAAACQp0RGnbtlx2ncuLGqV6+u559/XuPGjdPXX3+tlJQU3X333eratasqVaqktm3bavjw4WrVqpUKFChwEyIHAAAAbl8kNQAAAADkCaGhoQoI8Ff38ctybcyAAH+FhobmuL/JZNKyZcvUp08fVa9eXXfddZdWrFihkiVL6ttvv9Urr7yiV199Va1bt9bcuXNvYuQAAADA7YmkBgAAAIA8ISwsTJGRe2W1WnNtzNDQUIWFhV3TPiVLltRPP/2Uob1169bas2fPjQoNAAAAuCOR1AAAAACQZ4SFhV1zkgEAAADA7YOqdAAAAAAAAAAAIE8gqQEAAAAAAAAAAPIEkhoAAAAAblmGYXg6BI9wOp2eDgEAAAC4JVFTAwAAAMAtx9vbWyaTSWfPnlXhwoVlMpk8HVKuMAxDycnJOnv2rMxms3x8fDwdEgAAAHBLIakBAAAA4JZjsVhUqlQpHT9+XEeOHPF0OLkuICBAYWFhMpuZXA8AAACkR1IDAAAAwC0pMDBQlSpVUkpKiqdDyVUWi0VeXl53zOwUAAAA4FqQ1AAAAABwy7JYLLJYLJ4OAwAAAMAtgrnMAAAAAAAAQB5lu4a+iySln/94RNKWGxoNANx8JDUAAAAAAACAPGirpLKSrDno+7ekTpI2p2tbKqmrpOTrHP+QpD91bYkVAPi3WH4KOZJy7pinQwBwmf3iaUnS8SMHPBwJANx++LcVAADcyi5JMiR5SzJJmiKpg6RA/X9iwXn555Ar9v1GUj1JjS8fwySpv6RVkg5Iqn65X9q2qxkoaYGkUEkXJK2WdNd1nBMAXCuSGshWaGio/PwDdO7H9z0dCoB0zGazpowY4OkwAOC2FBAQoNDQUE+HAQAAkMEASd9JskiyK3UpKS9JsyUVuNzHrtSkhj3dfsmSZkl6RdIeSXUkBen/kxfNLv/XqdTER/hV4lgj6WelztQIlPScpAmSvri+0wKAa0JSA9kKCwvTvr2RslpzMpERQG5JSkqSr6+vp8MAgNtSaGiowsLCPB0GAABABl9efiVIelDSW5LySeoiKTqb/WZKOiMpWKkzMjJbbir+8rFyIuDyMQMvv68t6Zcc7gsA/xZJDVxVWFgYF/YAAAAAAAC3gARJPSQNl9ReqTUt0j/ylnL5FXD5vVXSKKXW3kiz7PJ+Yy+/T5RUUNJXkh7PQQyN0v18RqkzRV65hnMAgH+DQuEAAAAAAABAHtFE0iJJDyu1tkZTSVGS/C6/fCXVTdf/E6UmIZqlaysoabr+f8ZGhFKXnmpxjbHMkhQmqbiknte4LwBcL5IaAAAAAAAAQB4xVdJOpSYkUiT9IamMUuto2JSanIhI13+QpP9dcYz7JOXX/y8ZtUVSQ2UsLn41T0taLGmvUouWA0BuIKkBAAAAAAAA5BFNJNVS6iyNrKRfbz6fpBJXbDcpdabH8svvN+vaZ2lIqbNC2kgaLWnOdewPANeDmhoAAAAAAADALc4m6bRSkxnpn1I+J8kh90LhTqXO5CghySeL4z0oadjln9dJ+vQaYnlfUjFJ3S6/95JkuYb9AeDfIKkBAAAAAAAA3OK2Smqu1NkR6W/oOSTFS6qars0uKUmpy0rVvuI4TqUmRVoodcmoI5KOy73499VUktRbqUmTEpImSOpyDfsDwL9BUgMAAAAAAAC4xd2n1BoaV9os6XFJR6+yf4pSExrdJH2j1CWoJMm43B54+b1T0iFJZbM51iOShkp6SqkJlN76/1kfAHCzkdQAAAAAAAAA8qgkpS5NdTWxSk1sfCnpK2VdaNeunC0lNfTyCwByG0kNAAAAAAAAII+6X6m1Nq5mWQ6Px81CALe6rJKyAAAAAAAAyCG73e7pEAAAuCOQ1AAAAAAAAPgXrFarfv75Z3Xq1EmGp4MBAOA2R1IDAAAAAADgX9i1a5ecTqd8fX1dxZeB3LBU0o5cHnOVpI25PCYApEdSAwAAAAAA4DoZhqGIiAhJcv0XyA27Jb0mqVguj1tKUi9J0bk8LgCkIakBAAAAAABwnU6dOqXz58/LbDZr7969ng4Hd5B+kmbq/5Ma5ySVk3Tkin4vSTKle1VMty1CUgNJBSUNlXK0fNpdkt6U9Pp1xg0A/xZJDQAAAAAAgOuUNjujaNGiSk5O9nA0uFOsllRI0v2X31sldVDGhIYkbZW0XNKFy6/tl9uTJD0sqZ6kLZL2SPo8h+N3V2pC5PA1Rw4A/x5JDQAAAAAAgOtgGIZ2794tSSpZsqSHo8GdZJFSEwtpulx+Xcmu1ORDU0nBl19Bl7etkHRR0geSKkgaJ2l2Dsc3XR5v0bWFDQA3BEkNAAAAAACA6xAVFaXY2Fj5+vqqSJEing4Hd5Cdkhqmez9T0suZ9PtbqUtK3S3JX1IbSVHpjtFIUsDl97WUOltDkportW5GaUk9JT2v1ITIj+mO3ejyMQAgt5HUAAAAAAAAuA6hoaFq1aqVGjduLIvF4ulwcAc5Kyl9Gq18Fv0iJVWXNF+pCQtvSS9c3har1BocaUySLEpdokqSDkr6SNIXkmoqdXmrJen6F5Z05rrPAACun5enAwAAAAAAAMiL8uXLp3vvvVeStG3bNg9HgztJoKRLSq2rkZ1ul19ppik1ARKr1JuCvlf095OUcPnnp5Q6w0OS+ii1EPmRdH0vXY4DAHIbMzUAAAAAAACAPKSMpEPXsV+wJKekU5JClDrjI71Lknwu/+yXrt1PGR26HAcA5DaSGgAAAAAAANdo48aN2rFjh5KSkjwdCu5AbSQtzUG/wZK+Sff+L6XeDCwtqYGkP9NtOyIpSanJjpxYJqldDvsCwI3E8lMAAAAAAADXICUlRb/99puSk5MVEhKisLAwT4eEO8zjSi3U/YqyT0LcLelNScUk2SW9pNTC3wGSmkq6KOlLSU9LGi+ppVLralzNfkm7lFpQHAByG0kNAAAAAACAa/DPP/8oOTlZ+fPnV+nSpT0dDu5ABSUNkdRX0kKlFvnOzNNKLRb+qKQgSR0ljbu8zUvSTKXWzhgqySFpbQ7GTpL0nKT3lLMECADcaCQ1AAAAAAAArkFERIQkqUaNGjKZsrqdDNxczyt1+ahwSa0utxmZ9Hv38iszj0k6IGmLpMaSCl9u/y1dn7Rjjrj835mSWqQbEwByG0kNAAAAAACAHEpKStL+/fslpSY1AE+apX8/W6Lk5VdO9VbWM0MAIDeQ1AAAAAAAAMihvXv3ym63q1ChQipWrJinw8EdzhPLP5k9MCYApMe/QwAAAAAAADnE0lMAAHgWSQ0AAAAAAIAccDqdcjqdklh6CgAAT2H5KQAAAAAAgBwwm83q0aOH4uPjlS9fPk+HAwDAHYmZGgAAAAAAANeAhAYAAJ5DUgMAAAAAAOAqbDab4uLiPB0GAAB3PJIaAAAAAAAAV7F9+3Z98MEHWrVqladDAQDgjkZSAwAAAAAA4CoiIiJkGIYKFizo6VAAALijkdQAAAAAAADIxrlz53Ty5EmZTCbdddddng4HAIA7GkkNAAAAAACAbEREREiSypcvT5FwAAA8jKQGAAAAAABAFgzDcCU1atSo4eFoAAAASQ0AAAAAAIAsnD59WlarVRaLRVWrVvV0OAAA3PFIagAAAAAAAGQhbZZGpUqV5Ofn5+FoAACAl6cDAAAAAAAAuFXdd999CgkJUUhIiKdDAQAAIqkBAAAAAACQJX9/f9WtW9fTYQAAgMtYfgoAAAAAAAAAAOQJJDUAAAAAAACu4HQ69fXXX2vTpk1KSUnxdDgAAOAykhoAAAAAAABXOHLkiA4cOKC1a9fKbOb2CQAAtwr+rwwAAAAAAHCFXbt2SZKqVasmi8Xi4WgAAEAakhoAAAAAAADp2O127d27V5JUs2ZND0cDAADSI6kBAAAAAACQzsGDB2Wz2RQUFKSwsDBPhwMAANIhqQEAAAAAAJBORESEJKl69erU0wAA4BbD/5kBAAAAAAAuS05O1r59+yRJNWrU8HA0AADgSl6eDgAAAAAAAOBWkZiYqPLly+vcuXMqUaKEp8MBAABXIKkBAAAAAABwWYECBdSlSxc5nU6ZTCZPhwMAAK5AUgMAAAAAAOAK11tLI/IGxwEA4N9WuCOpAQAAAAAAICk6Olq+vr4qWLDgNe8bGhqqAD8/dbfZbkJkAIAAPz+FhoZ6OgzcAkhqAAAAAAAASFq1apUOHz6sRx55RHXq1LmmfcPCwhS5b5+sVutNig4A7myhoaEKCwvzdBi4BZDUAAAAAAAAd7xLly7p8OHDkqSyZcte1zHCwsK44QYAwE12fQtEAgAAAAAA3Eb27NkjSSpVqtR1LT8FAAByB0kNAAAAAABwx4uIiJAk1ahRw8ORAACA7JDUAAAAAAAAd7QLFy7o+PHjMplMuuuuuzwdDgAAyAZJDQAAAAAAcEdLm6VRtmxZBQUFeTgaAACQHZIaAAAAAADgjrZ//35JLD0FAEBe4OXpAAAAAAAAADzp6aef1v79+1W+fHlPhwIAAK6CpAYAAAAAALijeXt7q3r16p4OAwAA5ADLTwEAAAAAgDuSYRgyDMPTYQAAgGtAUgMAAAAAANyRTp48qRkzZmjjxo2eDgUAAOQQSQ0AAAAAAHBHioiI0NmzZ3Xy5ElPhwIAAHKIpAYAAAAAALjjOJ1O7d69W5JUo0YND0cDAAByiqQGAAAAAAC440RFRenSpUvy8/NThQoVPB0OAADIIZIaAAAAAADgjrNr1y5JUtWqVeXl5eXhaAAAQE6R1AAAAAAAAHcUh8OhyMhISVLNmjU9HA0AALgWJDUAAAAAAMAd5eDBg0pMTFS+fPlUtmxZT4cDAACuAfMrAQAAAADAHSUoKEi1atVS/vz5ZTbzvCcAAHkJSQ0AAAAAAHBHKV68uDp27OjpMAAAwHXgcQQAAAAAAAAAAJAnkNQAAAAAAAB3jJ07dyo6OlqGYXg6FAAAcB1IagAAAAAAgDuCzWbTsmXL9Mknn+js2bOeDgcAAFwHkhoAAAAAAOCOsHfvXjkcDoWGhqpw4cKeDgcAAFwHkhoAAAAAAOCOEBERIUmqUaOGTCaTh6MBAADXg6QGAAAAAAC47cXHx+vQoUOSpJo1a3o4GgAAcL1IagAAAAAAgNvenj17ZBiGSpQooZCQEE+HAwAArhNJDQAAAAAAcNtLW3qqevXqHo4EAAD8GyQ1AAAAAADAbS0pKUlWq1VSaj0NAACQd3l5OgAAAAAAAICbydfXV4MHD9bJkyeVP39+T4cDAAD+BWZqAAAAAACA257FYlHp0qU9HQYAAPiXSGoAAAAAAIDbVkpKigzD8HQYAADgBiGpAQAAAAAAblsbNmzQlClTtGPHDk+HAgAAbgCSGgAAAAAA4LZkGIYiIiJ08eJFmUwmT4cDAABuAJIaAAAAAADgthQdHa1z587Jy8tLVatW9XQ4AADgBiCpAQAAAAAAbksRERGSpMqVK8vX19fD0QAAgBuBpAYAAAAAALjtpC09JUnVq1f3cDQAAOBG8fJ0AAByT1RUlKxWq6fDAJBOaGiowsLCPB0GAADAbefYsWOKjY2Vj4+PKlWq5OlwAADADUJSA7hDREVFqVrVKkpItHk6FADpBPj7KXLvPhIbAAAAN9iuXbskSdWqVZO3t7eHowEAADcKSQ3gDmG1WpWQaNO8jv6qVpiV54BbQeRZp7r/kCir1UpSAwAA4AarXbu2JJaeAgDgdkNSA7jDVCtsVt3iFk+HAQAAAAA3ValSpVSqVKlcHZMlfwHg5mH5ZqQhqQEAAAAAAPAvRUVFqVqVKkqwseQvANwMAX5+itzH8s0gqQEAAAAAAG4jdrtd4eHhuuuuuxQWFiaTyZQr41qtViXYbJonqVqujAgAd45ISd1tNpZvhiSSGgAAAAAA4DZy4MABbd68WXv37tWgQYNyffxqkurm+qgAANw5qBYMAAAAAABuGxEREZJSC4Tn1iwNAACQe0hqAAAAAACA20JSUpL2798vSapRo4aHowEAADcDSQ0AAAAAAHBb2Ldvn+x2u0JCQlS8eHFPhwMAAG4CkhoAAAAAAOC2kLb0VI0aNVh6CgCA2xRJDQAAAAAAkOclJCTo4MGDkqSaNWt6OBoAAHCzeHk6AAAAAAAAgH/r/PnzCgoKkr+/v0JDQz0dDgAAuElIagAAAAAAgDyvVKlSevnllxUfH+/pUAAAwE3E8lMAAAAAAOC2YDKZFBgY6OkwAADATURSAwAAAAAA5GkXL16Uw+HwdBgAACAXsPwUAAAAAADI07755hvFxMTo8ccfV9myZT0dDgAAuIlIagAAAAAAgDzr/PnzOnnypEwmEwXCAQC4A7D8FAAAAAAAyLMiIiIkSeXKlaOeBgAAdwCSGgAAAAAAIM9KS2rUqFHDw5EAAIDcQFIDAAAAAADkSadPn9bZs2dlsVhUrVo1T4cDAAByAUkNAAAAAACQJ6XN0qhYsaL8/Pw8HA0AAMgNJDUAAAAAAECeYxgGS08BAHAH8vJ0AAAAAAAAANfjySef1O7du1WlShVPhwIAAHIJSQ0AAAAAAJDnmEwmFStWTMWKFfN0KAAAIBex/BQAAAAAAAAAAMgTSGoAAAAAAIA85ejRo1q0aJEOHTrk6VAAAEAuY/kpAAAAAACQp+zcuVO7du2St7e3ypcv7+lwAABALmKmBgAAAAAAyDMcDociIyMlSTVq1PBwNAAAILeR1AAAAAAAAHnGP//8I5vNpsDAQJUpU8bT4QAAgFxGUgMAAAAAAOQZERERkqTq1avLbOa2BgAAdxr+7w8AAAAAAPKE5ORk7du3TxJLTwEAcKciqQEAAAAAAPKE/fv3KyUlRQULFlTJkiU9HQ5wS7BdQ99FklLSvT8iacsNjQYAbj6SGgAAAAAAIE8wm80qXLiwqlevLpPJ5OlwAI/bKqmsJGsO+v4tqZOkzenalkrqKin5hkcGADePl6cDAAAAAAAAyIm77rpLd911lxwOh6dDATzikiRDkrckk6QpkjpICtT/z9hwXv455Ip9v5FUT1Ljy8cwSeovaZWkA5KqX+6Xtu1qRl4eP17SY5I+lRR07acEANfshs7UiIqKupGHAwAAAAAAyMBisXg6BMAjBkgqJqmIpIKSvpY0T5L/5fa0bUWu2C9Z0ixJnSXtkeQrqdDl/n9KaiYpVKmJkFY5iOOry+OulLRb0k5J46//tADgmlxTUqN169bZbi9fvrycTue/CggAAAAAAOBKhw8fVkpKytU7ArexLyUlSDotqbakJUpNLBSVFHP5FSfJfsV+MyWdkRSs1BkZyZLOKXXZqrTXUUnnJYXnII4oSZ9LukdSRUlPitocAHLPNSU1tm7dKkn6/vvvFRMTk2G7yWSS2UyZDgAAAAAAcOPExcVp7ty5mjhxohISEjwdDuBRCZJ6SBouqb0kP6XOvEiTcrlPGqukUUqtvZFmmaQ3071PVOrMj29zGMN/Jd2X7v0+pSY3ACA3XFNNDbPZrMTERD311FMyDEMNGzZUixYt1KJFCzVs2JAiXQAAAAAA4IbbvXu3DMNQkSJFFBAQ4OlwAI9qImm7pEVKvbFnUmoiw+/y9mRJlSXtvfz+E0mN5F5jo6Ck6ZLekeQjKUKptThaXEc8+yT9IGZqAMg9OZpWYbfbtWfPHkmSv7+/Ll68qD/++EPdunVTVFSUnn32WRUoUIBCXQAAAAAA4IaLiIiQJNWoUcPDkQCeN1WpNSySlZrM+ENSGaUWB7cpNTkRka7/IEn/u+IY90nKL+mXy++3SGqojMXFr8YhqZek3pJqXuO+AHC9rprU2Lp1q6pXr67XXnvN1ebn56f69eurb9+++uyzz3TgwAFFRkb+q6WnbDZbjvsuWrTIbR3NI0eOaMsW8sEAAAAAANxuYmJidPz4cUlS9erVPRwN4HlNJNWS5J1Nn/RLs+STVOKK7SZJD0tafvn9Zl3fLI2Rki5Kmngd+wLA9bpqFiI0NFQvvviiFi9eLMMwXO12u10rV67USy+9pMqVK2vPnj3XvfzU1q1bVbZsWVmt1qv2/fvvv9WpUydt3rzZ1bZ06VJ17dpVycnJ1zU+ANyy7n5KGnEx9TX8jNTnV6lE3dRt9XpKQ/ZJb1mlHj9IgUU9GioAAABwM6TN0ihbtqyCgoI8HA3wf+zdd3xUVd7H8e+0dBISQgklCb1FOogUQRAsYEHQRcWCZe1rW59dRZdVdy2rqyiuBcWCoi6KqFjpCC4R6YRQhRA6BNJIMsmU+/wxZExIIQmZTMrn/TzzSubec8/53bPcOHd+95zjP3Z5FvM+KOlwkddxeUZMFN12UFKKPKM5yjJC0o+nfl9x6n1lfCXpFUlzJTEpHICadMakRlxcnO677z5ZLBbvtscff1zNmjXTXXfdJUl6/vnnNWTIkAo3mp2draysLOXl5clut+uVV17R2LFjFRYWJrvdLrvdrtzcXJ04caLEsXPmzFHfvn01aNAgb5Ll7rvvVufOnbVz505vuaIJmPI8+eSTioqKUmBgoP7whz8oOzu7wucBADXiyBbpuVjppa7Szh+laz6QYgdKF0yR5t0hvdJDsgZKo//h70gBAACAasfUU4DHWnkW4+4kqUuR1wRJB07b1klSR0lbS6nHfernSHmSEimS9suz7kZFJUu6TtJrklpLOqnii5MDgC9VaqHwrKwsSdLAgQN1ySWXaPDgwcX2u93u0g4r4Z577tHnn38ui8Uip9Mph8Mhq9WqmTNnKiIiQpJnJIjdbpfT6fQeV1BQoLffflsPPvigkpOT1bt3bzVq1Mg7QmTYsGHeOPr27auFCxeWG8fs2bP10Ucf6YcfflBUVJTGjh2r5557Tv/85z8r1iEAUBMMl2TP9Py+9n1p+KNSm4HStw9Ju5d5tq+fLQ150F8RAgAAAD6Rnp6uI0eOyGw2q1u3bv4OB/CrwfKsoXG61ZKulmcUR3kc8iQ0rpc0R54pqCTJOLU97NR7t6TdkuLLqWuGPEmMG4tsi5MnQQIAvnbGpIbL5dLq1at13nnnaf369ZKksWPHlihnGIauueYauVyuYqM6SjNr1izNmjVLubm5GjFihJ544gmFhoZq4sSJOnz4cJnHzZgxQ0ePHlXjxo3VvXv3UqebysnJUWho6JlOS5KUmpqq999/XwMGDJAk/eEPf1BiYmKFjgUAv+h2pZR1UPrfq5JRJJEc3VE6sdtvYQEAAAC+EBkZqT/96U86cOCAgoOD/R0OUCvlyzM11ZlkyZPYmCVptsqevsUpqfxv9qRpp14A4A9nTGp8/fXXGj9+vPr166cJEyZo5cqVZZY9//zz9frrr+u+++47Y8O5ubm64YYb9Pjjj2vMmDFKTExUYGCgd7/D4ZDD4VBIiGdWvrS0ND311FOKj4/3lpk/f74SExO9Iyvy8vIUGRmp2bNn6+qrrz5jDI8++mix99u3b1eHDh3KLJ+fn6/8/Hzv+8KRKwDgU826S3/dK5ltktkifTS+eEIjOFLqO1n64nb/xQgAAAD4SGRkpCIjI/0dRrkMw1BKSorne40i3xsANWGopCMVKDe/gvVValoXAPCDM/6dGjdunDZs2KA5c+bopZde0rFjxxQfH69hw4aVWLfC4XAoOzu7QkmNIUOGaP369friiy9ktVplMpnkcDgUFBQkyTPVVKdOnbRt2zZJ0ltvvaWBAwcqKirKW0dkZKRef/11TZ06VQEBAUpKSpLb7dbIkSMr1QmSJ6Exb948rVmzpswyzz77rJ588slK1w0AZ+X4Tmn21ZItWOp/u3T5dOmNwZLj1IylY16S9v0i7Vzg3zgBAACABmrbtm3avHmz7rrrLrmnT5dcLn+HBABAvVWh5GuPHj3Uo0cPTZ06VW+99ZaefvppnThxQm+++aZatGhRpYZfffVVhYeHq2vXrrLZbFqzZo0mTJiglJQUb5mi62k88MADyszM1GOPPebdNnjwYIWHh2vRokW69NJLtWbNGp177rnFEh8V4XK5NHnyZN12220655xzyiz36KOP6qGHHvK+z8rKUps2bSrVFgBUmqtAykj1/P7dn6VH90ntL5C2fSv1niTFDZLeHOLfGAEAAIBqtnjxYh07dkyDBg1SbGysv8Mpk8vl0qJFiyRJGzdu1A0kNFCDvpYUK6lXDba5QFIjSefVYJsAUFRZ0+eVymaz6d5771VycrIGDBhQbFHvzZs3V6rhIUOGqEePHrLZbGWWsVp/z7mEhoaqZcuWxfabTCZddtll+vbbbyVJq1evrtIojSeffFKZmZl64YUXyi0XGBio8PDwYi8AqHkmyWyVWvWRLn5W+vwWKeeYv4MCAAAAqo1hGNq4caO2b9+u3Nxcf4dTrjVr1ujEiRMKCAjQzz//7O9w0IBskfQXSVV73LjqWkuaLKnsVXEBwLcqldQo1KRJEz322GPeRboOHDigfv36VehYu92uvXv36uDBgzp8+LD3dfz4cblcrmLbDh48qJSUlFIXBC80YsQI/fjjj5KkFStWaMSIEZU6l6+++kqvvPKK5s6d612/AwBqFZNFCoqQwltJI6dK1kDpwDrp2v9KK1+RDm2QAkI9LwAAAKAeSE1NVXZ2tgIDA8td+9LfCpMvktS5c+dyv78Aqttdkmbo96TGcUltJaWcVi5JUn9JkZIekWRUcF9ZukmaIumvVYwbAM5Whdf+SU9PV/PmzVVQUKC8vDz17dtXSUlJMpvNCggIUEBAQIXqWbt2rYYPH67AwMBiIzFcLpdycnLUpUsX7zan06n8/HytWbNGPXv2LFaP2+2W2WzWyJEj9corryglJUX79+/XwIEDK3pKSk5O1nXXXac333xTrVu31smTJ2U2m0luAKhdmneX/poqOe3S0W3SfydJXcdKYc2kkU94XoX+HuG/OAEAAIBqUjgbRNeuXYt9d1DbmEwmTZ48WRs2bJDJZPJ3OGhAFktqIs8i4ZKUJukylUxo5J/afpGkTyX9SdL78oy0KG/fmUyS9IqkPfIkUgCgJlX4k0FQUJACAwMleaah2r59u8xmz0APs9lc7jRSRQ0ePFgOh6PE9tWrV+vqq6/W3r17yz3e4XDI7Xbr+uuv15w5c7wfGgzDkNvtVlhYmCRP0mP37t2Kj48vs64ZM2YoNzdXN954o3dbXFxcsXU9AMCvNnzseZUm8Y2ajQUAAACoAS6XS8nJyZKkhIQEP0dzZjabTf3799e6dev8HQoakC/kSSwUmnjqlXhaue8lZUp6SVKIpGck3SNP4qK8fWdiOtXeF5IerupJAEAVVXj6qaKJC6vV6k1wVJf8/HzZ7fYzlsvKypLD4dCsWbPkcDjkdDrldDrlcrlkGIb3fUFBgeLi4sqta9q0aTIMo9iLhAYAAAAAAP6ze/du5eXlKTQ0VG3b1t5nwPfs2SO32+3vMNBAbZR0bpH3MyTdX0a5gfIkLSSph6TkCuwbLk9yo42kmyX9UVJjSd8UqXvgqToAoKbVmjGcQ4cO1ZEjR85Ybv78+RWqrzYPTwUAAAAAAKVLSkqSJHXr1s07Q0Rtc+DAAc2aNUvNmzfXrbfeWuHZK4DqckxSsyLv25VRLkvFp4cySbJISj/DPkn6TdJ0SeMkvSopV9JXksae2t9U0tEqnwEAVF2Fvvk/ceKEQkNDlZGRoZYtWyowMFD5+flq187zJ9PlcikrK0tt27aV3W7XoUOHfBo0AAAAAACon+Li4nTixIlaO/WUYRhasGCBJKlFixYkNOAXYZKy5VlXozxWSafPtRIkT4KivH2SdJ2kXqd+v12ehchTipTNPhUHANS0MyY18vPz1b17d1122WUKCgrSp59+qoCAAA0fPlyfffaZJCktLU3XXHON5syZo/z8fJ8HDQAAAAAA6qc+ffqoT58+/g6jTNu2bVNqaqqsVqtGjBjh73DQQMVJ2q0zJzWiJCWdti1bUsAZ9kmeBIdK+b3Q7lNxAEBNO+M4zsDAQH3zzTey2+1yOp3Kzc3VwIEDZRiG+vbtq759+6pXr16yWCzq37+/hgwZUhNxAwAAAAAA1CiXy6VFixZJks477zyFh4f7OSI0VBdL+roC5fqr+OLhKZLy5UlolLevIuZLurSCZQGgOlVocsq+fftqxowZslqteuqpp/Tdd995F+cGAAAAAAA4W/n5+Vq7dq3y8vL8HUqZ1qxZ452ie/Dgwf4OBw3Y1ZLmSDpxhnLnS8qUNOvU++ckXSjP2hnl7TuTHZI2y7OgOADUtEqtuGWz2bR48WLNnDlTkrR161afBAUAAAAAABqWbdu26ZtvvtEHH3zg71BKZbfbtXz5cknS8OHDFRh4+moEQM2JlPSwpDslGeWUs0qacapcc0mfy5O8ONO+8uRLulXSv1SxBAgAVLcKLRQuSQ6HQ06nU8HBwfrwww81dOhQZWVlSZLcbrecTqfPggQAAAAAAPVbUpJndv+uXbv6OZLS5eXlqWnTpsrNza3Va36g4fijPNNHLZQ0+tS20hIcV0raKWmNpEGSmlZg37IiZQrr/PupnzMkjSzSJgDUtAonNUwmkyZMmCBJCgkJ0dq1a737HA6H7HZ79UcHAAAAAADqvZycHP3222+SpISEBD9HU7rIyEjdfPPNysnJkdlcqYkvAJ95WxUbLdHq1Kuy+0pzmyRTJcoDQHWrcFIjLCyszCGgzZs317Jly6orJgAAAAAA0IAkJyfLMAzFxMSoSZMm/g6nTCaTSWFhYf4OA/Dyx/RPpPQA+Fu1/B0KDAzUoEGDqqMqAAAAAADQwBROPVUbR2kcOHBACxcuZIYKAABqiQqP1AAAAAAAAKhumZmZSk1NlSR1797dz9EUZxiGFixYoNTUVBUUFGjMmDH+DgkAgAaPpAYAAAAAAPCb/fv3y2QyqU2bNoqIiPB3OMVs375dqampslqtGjp0qL/DAQAAIqkBAAAAAAD8qHv37oqLi1NOTo6/QynG5XJp4cKFkqTzzjtP4eHhfo4IAABIJDUAAAAAAICfhYWF1boFuNeuXasTJ04oNDRUgwcP9nc4AADglGpZKBwAAAAAAKCynE6nv0Mold1u17JlyyRJw4cPV2BgoH8DAgAAXozUAAAAAAAANc4wDM2YMUOhoaEaO3asmjRp4u+QvFauXKm8vDxFR0erT58+/g4HAAAUQVIDAAAAAADUuCNHjujYsWM6ceJErZt6asCAAcrJyVHXrl1lNjPJBQAAtQlJDQAAAAAAUOM2b94sSerUqVOtm94pPDxcV1xxhb/DAAAApeBxAwAAAAAAUKMMw9CWLVskSQkJCX6O5ncOh8PfIQAAgDNgpAYAAAAAAKhR+/btU2ZmpgICAtSxY0d/hyPJk2j56KOPFBISoosuukiNGzf2d0gAAKAUjNQAAAAAAAA1KikpSZLUpUsX2Ww2P0fjsX37dqWmpmrXrl0ymUz+DgcAAJSBpAYAAAAAAKgxbrdbycnJkmrP1FMul0sLFy6UJJ133nmKiIjwc0QAAKAsTD8FAAAAAABqjGEYuvDCC7Vz5061a9fO3+FIktasWaMTJ04oNDRUgwcP9nc4AACgHCQ1AAAAAABAjbFYLOrVq5d69erl71AkSXa7XcuXL5ckDR8+XIGBgX6OCAAAlIfppwAAAAAAQIO1YsUK5eXlKTo6Wn369PF3OAAA4AxIagAAAAAAgBqRkpKiVatWKSsry9+hSPKspbFt2zZJ0qhRo2Q28zUJAAC1HdNPAQAAAACAGrFmzRpt2bJFWVlZuuiii/wdjiwWi+68804lJyerY8eO/g4HAABUAEkNAAAAAADgcwUFBdq+fbsk6ZxzzvFzNL+z2Wzq2bOnv8MAAAAVxLhKAAAAAADgc9u3b5fT6VRUVJRiYmL8GothGNq2bZvcbrdf4wAAAJVHUgMAAAAAAPhcUlKSJKl79+4ymUx+jWX79u3673//q3fffVeGYfg1FgAAUDkkNQAAAAAAgE/l5eVp165dkvw/9ZTL5dLChQslSe3atfN7ggUAAFQOSQ0AAAAAAOBTycnJcrvdat68uZo2berXWNauXasTJ04oNDRUgwcP9mssAACg8khqAAAAAAAAnzp58qQsFosSEhL8GofdbteyZcskScOHD1dgYKBf4wEAAJVn9XcAAAAAAACgfhs2bJgGDhzo9/UrVq5cqby8PEVHR6tPnz4+aWOrT2oFgIaNv60oiqQGAAAAAADwOX+PisjIyFBiYqIkadSoUTKbq3fyiujoaIUEBWmS3V6t9QIAPEKCghQdHe3vMFALkNQAAAAAAAA+k5mZqYiICH+HIYfDoZYtW8pqtapjx47VXn9sbKy2bt+utLS0aq8bAOBJHsfGxvo7DNQCJDUAAAAAAIBPpKen69VXX1XLli11yy23yGKx+C2Wpk2bavLkycrPz5fJZPJJG7GxsXzhBgCAj5HUABqYrcfc/g4BwClcjwAAoL5LSkqSJAUFBfk1oVHIZDIpKCjI32EAAICzQFIDaCCio6MVEhykSfPy/B0KgCJCgpkTFAAA1F+FSY3u3bv7LYbt27crNTVVQ4cOJaEBAEA9QFIDaCBiY2O1dRvzuwK1DXOCAgCA+uro0aM6evSozGazunbt6pcYXC6XFixYoBMnTshms2n48OF+iQMAAFQfkhpAA8L8rgAAAABqyubNmyVJHTt2VHBwsF9iWLt2rU6cOKHQ0FCdd955fokBAABUL7O/AwAAAAAAAPWLYRjasmWLJCkhIcEvMdjtdi1btkySNHz4cAUGBvolDgAAUL1IagAAAAAAgGp18OBBpaeny2azqVOnTn6JYeXKlcrLy1N0dLT69OnjlxgAAED1Y/opAAAAAABQrZo3b65rrrlGWVlZCggIqPH2MzIylJiYKEkaNWqUzGae6QQAoL4gqQEAAAAAAKqV1Wr12+LgkrRs2TK5XC61bdtWHTt29FscAACg+pHUAAAAAAAA9cqIESNkMpk0YMAAmUwmf4cDAACqEUkNAAAAAABQbZYvXy63260+ffooIiLCLzGEh4friiuu8EvbAADAt0hqAAAAAACAauFyuZSYmCi73a64uLgaT2rk5+crMDCwRtsEAAA1i5WyAAAAAABAtfjtt99kt9sVFham+Pj4Gm3b5XLp7bff1n//+19lZ2fXaNsAAKDmMFIDAAAAAABUi6SkJElSt27dZDbX7HOUa9eu1fHjx2W32xUQEFCjbQMAgJrDSA0AAAAAAHDWHA6Htm3bJkk655xzarRtu92u5cuXS5KGDx/OFFQAANRjJDUAAAAAAMBZ27FjhxwOhxo3bqxWrVrVaNsrV65Ubm6uoqOj1adPnxptGwAA1CySGgAAAAAA4KwVTj2VkJAgk8lUY+1mZGQoMTFRkjRq1Kgan/YKAADULP5LDwAAAAAAzophGAoLC1NgYKASEhJqtO0lS5bI5XIpPj5eHTt2rNG2AQBAzWOhcAAAAAAAcFZMJpPGjBmjiy66SBaLpcbazc/PV2pqqiRp9OjRNTpCBAAA+AdJDQAAAAAAUC2s1pr9miEwMFD33HOPdu/erZiYmBptGwAA+AfTTwEAAAAAgCrLy8vTwYMHZRiGX9q32Wzq3LmzX9oGAAA1j6QGAAAAAACoss2bN+vtt9/W559/XmNtulwubd68WW63u8baBAAAtQNJDQAAAAAAUGVJSUmSpNatW9dYm2vXrtUXX3yh2bNn11ibAACgdiCpAQAAAAAAqiQzM1P79u2TJHXv3r1G2rTb7Vq2bJkkqWvXrjXSJgAAqD1IagAAAAAAgCopHKURFxen8PDwGmlz5cqVysvLU3R0tPr06VMjbQIAgNqDpAYAAAAAAKiSwqRGQkJCjbSXkZGhxMRESdKoUaNkNvO1BgAADQ3/9QcAAAAAAJWWlpamw4cPy2w2q1u3bjXS5pIlS+RyuRQfH6+OHTvWSJsAAKB2IakBAAAAAAAqbevWrZKk9u3bKyQkxOftHThwQJs3b5YkjR49WiaTyedtAgCA2sfq7wAAAAAAAEDdM3jwYLVq1Uo2m61G2rNYLGrTpo2ioqIUExNTI20CAIDax2QYhuHvIOqqrKwsRUREKDMzs8YWRAMAAADOBp9hAdRlhmHI6XTWWCIFAADUPkw/BQAAAAAA6gSTyURCAwCABo6kBgAAAAAAqDDDMDRz5kz9+OOPysvL83l7a9eu1aJFi2S3233eFgAAqP1IagAAAAAAgApLTU3V/v37tX79ep+PmrDb7VqyZIl+/vlnJSUl+bQtAABQN5DUAAAAAAAAFVaYXOjSpYusVqtP21q5cqVyc3MVHR2t3r17+7QtAABQN5DUAAAAAAAAFeJyuZScnCxJSkhI8GlbGRkZSkxMlCRdeOGFslgsPm0PAADUDSQ1AAAAAABAhezZs0e5ubkKCQlRu3btfNrWkiVL5HK5FB8fr06dOvm0LQAAUHeQ1AAAAAAAABVSOPVUt27dZDb77iuFAwcOaPPmzZKk0aNHy2Qy+awtAABQt5DUAAAAAAAAZ+R0OrV161ZJ0jnnnOPTtpYuXSpJ6tGjh2JiYnzaFgAAqFtIagAAAAAAgDMqKChQr1691KpVK7Vp08anbV1++eXq3bu3RowY4dN2AABA3WMyDMPwdxB1VVZWliIiIpSZmanw8HB/hwMAAACcEZ9hAcB3UlNTlZaW5u8wAKBeio6OVmxsrL/DQC1g9XcAAAAAAAAAkryLkNdFqamp6tq5s3Ltdn+HAgD1UkhQkLZu305iAyQ1AAAAAABA+fbt2yen06m4uDifLRBut9v1n//8R3FxcbrssssUHBzsk3Z8JS0tTbl2uz6S1NXfwQBAPbNV0iS7XWlpaSQ1QFIDAAAAAACU76efftKuXbs0cuRIDRkyxCdtrFy5Urm5uTp27JgCAwN90kZN6Cqpj7+DAACgHmOhcAAAAAAAUKbc3Fzt3r1bktSlSxeftJGRkaHExERJ0qhRo3w2GgQAANR9fEoAAAAAAABlSk5OltvtVosWLRQdHe2TNpYsWSKXy6X4+Hh17NjRJ20AAID6gaQGAAAAAAAoU1JSkiQpISHBJ/UfPHhQmzdvliSNHj1aJpPJJ+0AAID6gaQGAAAAAAAoVVZWlvbu3SvJN0kNwzC0YMECSVKPHj0UExNT7W0AAID6haQGAAAAAAAo1ZYtWyRJsbGxioiIqPb6T548qfT0dFmtVo0YMaLa6wcAAPWP1d8BAAAAAACA2ik1NVWS76aeatSoke69914dOHDAJ0kTAABQ/5DUAAAAAAAApbrmmmt08OBBRUVF+awNm82m+Ph4n9UPAADqF6afAgAAAAAApTKZTGrVqpWCg4OrtV673a4NGzbI7XZXa70AAKD+I6kBAAAAAACKMQxDLpfLZ/WvXLlSX331lebOneuzNgAAQP1EUgMAAAAAABRz9OhRvfjii/ruu+9kGEa11p2ZmanExERJUo8ePaq1bgAAUP+R1AAAAAAAAMVs3rxZdrtd2dnZMplM1Vr34sWL5XK5FB8fr06dOlVr3QAAoP4jqQEAAAAAALwMw9CWLVskSQkJCdVa98GDB7V582ZJ0qhRo6o9YQIAAOo/khoAAAAAAMBr//79ysjIUEBAQLWOpDAMQwsWLJDkmXaqZcuW1VY3AABoOEhqAAAAAAAAr6SkJElS586dZbPZqq3e7du3a+/evbJarRoxYkS11QsAABoWq78DAAAAAAAAtYPb7fbZ1FPh4eFq3bq14uPjFRERUa11AwCAhoOkBgAAAAAAkCSlpKQoJydHwcHBat++fbXW3bJlS91yyy1yu93VWi8AAGhYSGoAAAAAAABJUlRUlIYOHSqLxSKLxVLt9ZtMJp/UCwAAGg6SGgAAAAAAQJLUuHHjal/vYtmyZXI6nRo6dKgCAwOrtW4AANDwkNQAAAAAAAA+kZmZqZUrV8rlcqlNmzbq3Lmzv0MCAAB1nNnfAQAAAAAAAP/75ZdftG3bNjmdzmqrc8mSJXK5XIqPj1enTp2qrV4AANBwkdQAAAAAAKCBKygo0OLFi/Xf//5XR44cqZY6Dx48qE2bNkmSRo8eLZPJVC31AgCAho2kBgAAAAAADdz27dvlcDgUGRmpli1bnnV9hmFowYIFkqQePXooJibmrOsEAACQSGoAAAAAANDgJSUlSZISEhKqZUTFjh07tHfvXlmt1mpfeBwAADRsJDUAAAAAAGjA8vLytGvXLkmepMbZMgxDy5YtkyQNHDhQERERZ10nAABAIZIaAAAAAAA0YFu3bpXb7VazZs3UrFmzs67PZDJp4sSJ6tevn4YMGVINEQIoj70SZb+Q5CjyPkXSmmqNBgB8j6QGAAAAAAANWNGpp6pLRESExowZo8DAwGqrE0BJayXFS0qrQNlNksZLWl1k29eSrpVUUO2RAYDvkNQAAAAAAKCBcrlcsts9z3lXR1IjKyvrrOsAULZsSVmS8uQZofGKpLGSwk69t0vKlXSilGPnSOoraZAk49S2uyV1lrSzSDlDFbfq1PEAUJOs/g4AAAAAAAD4h8Vi0R//+Eelp6crMjLyrOrKzMzUa6+9po4dO+rKK69UQEBANUUJoNA9kj6XZJHklGcqKaukmZIKV69xypPccBY5rkDS25IelJQsqbekRpJMp/YPO/XTLU/iY2EFYlknaZykoKqdCgBUGSM1AAAAAABo4M42oSFJS5YskdPpVF5enmw2WzVEBeB0s+QZiXFEUk9JX0n6QVJzSRmnXidVPKEhSTMkHZXUWFJ3eZIcx+WZtqrwtVeeER4VSWjkyJPQuLvqpwIAVUZSAwAAAACABshutys/P79a6jp48KA2bdokSRo1apRMJtMZjgBQVbmSbpD0uKQx8oyUKLp6jeNUmUJpkp6SZ+2NQvMlTSnyPk9SpKTPKhiDTdL/JJ1fibgBoLqQ1AAAAAAAoAH69ddf9eKLL+qnn346q3oMw9CCBQskST169FDLli2rIzwAZRgi6QtJl8mTXDhfUqo8yY3CBEefIuXfkjRQv08xJXkSGK/r9wXCk+SZempkBWMIkNSqauEDwFkjqQEAAAAAQAOUlJQkp9OpsLCws6pnx44d2rt3r6xWq0aMGFFN0QEoy6uSNsqTkHDIM2IiTr8vFO6WJ0lR6AFJb55Wx2BJ4ZIWnXq/RtK5kqJ8FTQAVCOSGgAAAAAANDBHjx7V0aNHZTab1bVr1yrX43K5tHChZwb+gQMHKiIi4gxHADhbQyT1kGeURlmsRX4PlXT6+CmTPCM9vj31frUqPkoDAPzNeuYiAAAAAACgPklK8jzH3aFDBwUHB1e5nvT0dBUUFCgkJERDhgyprvAAlMIuzwLhNhV/Svm4JJekw0W2ueUZydFSnqmiSjNC0v+d+n2FpHeqM1gA8CGSGgAAAAAANCCGYXiTGgkJCWdVV3R0tO677z4dO3ZMgYGBZz4AQJWtlTRcnjUzin6h55KUI6lLkW1OSfnyTCvV87R63PIkRUZKekVSiqT98qy7AQB1AUkNAAAAAAAakIMHDyo9PV02m02dO3c+6/psNhuLgwM1YLA8a2icbrWkqyXtPcPxDnkSGtdLmiPPFFSSZJzaXri6jlvSbknxZxcuAPgMa2oAAAAAANCAFI7S6NSpkwICypqYpnyZmZnasGGD3G53dYYGoAry5Zma6kyy5ElszDr103nq5ZInsVH4vkCehccrYrg8Iz0AoCYxUgMAAAAAgAZk4MCBCgsLU6tWrapcx5IlS7Rp0ybt379fY8eOrcboAFTWUHnW2jiT+RWsjy8LAdR2/J0CAAAAAKABiYiI0ODBg6t8/KFDh7Rp0yZJUp8+faorrDpr586dWrdundq3b+/vUAAAaBBIagAAAAAAgAoxDEMLFiyQJPXo0aNBr6XhdDq1aNEi/fLLL5Ikq5WvWOBfX0uKldSrmutdIKmRpPOquV4AqCrW1AAAAAAAoAFwuVz6/PPPtXHjRrlcrirVsWPHDqWkpMhisWjEiBHVHGHdcezYMb3zzjvehMaAAQMUGxvr56jQkG2R9BdJLXxQd2tJkyUd9kHdAFAVJDUAAAAAAGgAdu/erS1btmjhwoUymUyVPt7lcmnhwoWSPOtyREREVHeItZ5hGFqzZo1mzJihI0eOKCQkRNdee60uueQSWSwWf4eHBuwuSTPkSWrcJ8lU5NWhSLkkSf0lRUp6RJ4Fws+km6Qpkv5ajfECwNkgqQEAAAAAQAOQlJQkSerevbvM5sp/HbBu3TodP35cISEhGjJkSHWHVycsXrxY3377rZxOp9q3b68777xTnTp18ndYaOAWS2oiz4LhkrRW0reS0k+91p/ani/pMkl9Ja2RlCzp/Qq2MUmehMieaokYAM4OSQ0AAAAAAOo5h8Ohbdu2SZISEhKqVEdMTIxatWqlYcOGKSgoqDrDqzN69uypwMBAjR49Wtdff70aNWrk75AAfSFP0kGSnPIkH86X1PjUq/Bf6feSMiW9JKm9pGckzaxgGyZJE0+1BQD+RlIDAAAAAIB6bseOHSooKFDjxo3VunXrKtXRunVr3XrrrerXr181R1d7uVwu7dnz+7PpTZs21QMPPKDzzjuvSlN4Ab6wUdK5p37fJM+UUr0kBUu6WFJqkXIDJYWcet9DntEakjRcnnUz2ki6WdIf5UmIfFOknYGn6gAAfyOpAQAAAABAPVd06qmz+TLeZDJVaeqquujEiRN677339OGHHyo1NdW7vaGOUkHtdUxSs1O/b5XUXdIn8iQsbJLuOLUvS1LbIseZJFnkmaJKkn6TNF3SB5LOkTRW0ldFyjeVdLT6wweASrP6OwAAAAAAAOA7drtdO3fulCSdc845lT5+/vz5Cg0N1eDBgxUYGFjd4dVKGzdu1HfffaeCggIFBQXJbrf7OySgTGGSsuVZV+P6U69Cr0lqJ09Cwyrp9Cs4SFLuqd+vk2eEhyTdLum4pJQiZbNPtQUA/kZSAwAAAACAeuzkyZNq1aqV7Ha7mjVrduYDijh48KDWrVsnSerSpYtatmzpixBrjfz8fH377bfavHmzJCk2NlZXXXWVIiIi/BwZULY4SbvlSWqcrrEkt6RDkqLkWW+jqGxJAad+LzoGqbTxSLtPtQUA/kZSA5CUmpqqtLQ0f4eBahAdHa3Y2Fh/hwEAAADUGtHR0Zo8ebIcDkelpp4yDEMLFy6U5BnhUd8TGvv379fcuXOVkZEhk8mkYcOGaejQoQ1mui3UXRdL+lpSf0kPybP2xTWn9v0qz9zzbU7tf6fIcSmS8uVJdlTEfHnW2wAAfyOpgQYvNTVVXbt2UW5unr9DQTUICQnW1q3bSGwAAAAAp7HZbJUqv2PHDqWkpMhisWjEiBE+iqr2OHTokDIyMtS4cWNdddVVatOmjb9DAirkankSGQ/KM33UFEktJDkl3SdPIiJE0vmSMiXNknSjpOckXSjPuhpnskPSZnkWFAcAfyOpgQYvLS1Nubl5+uivl6lrbGmDNVFXbE09rknPzVdaWhpJDQAAAEDS0aNHFRoaqtDQ0Eod53K5vKM0Bg4cqMaNG/sgOv8zDMM7eqVfv35yuVzq1asXi4GjTomU9LCkOyX9V57Fwq+Q1EjSOEnPnCpnlTRDnrUzHpHkkrS8AvXnS7pV0r9UsQQIAPgaSQ3glK6xTdSnYwt/hwEAAAAA1ebbb7/Vvn37NGHCBHXr1q3Cx61bt07Hjx9XSEiIhgwZ4sMI/Wfr1q1asWKFbrzxRgUFBclkMmngwIH+Dguokj9KSpS0UNKzp16luVLSTklrJA2S1PTU9mVFyhinfv791M8ZkkZKGl1dwQLAWSKpAQAAAABAPZSZmanU1FRJUuvWrSt8nNvt1s8//yxJGjZsWL0btVBQUKAff/zRuwD6qlWrdMEFF/g5KuDsva2KjaRodepVUbdJqvhqPADgeyQ1AAAAAACoh5KSkiRJcXFxCg8Pr/BxZrNZkydP1i+//KK+ffv6Kjy/OHz4sObOnau0tDRJ0uDBg3X++ef7OSqgevhqaiizj+oFgKoiqQEAAAAAQD1UmNRISEio9LEREREaPbr+TDZjGIYSExO1ePFiuVwuNWrUSOPGjVPbtm39HRoAAKgkkhoAAAAAANQzaWlpOnz4sMxmc6XW0jhx4oSioqJ8GJl/rFixQkuXLpUkde7cWZdffrlCQkL8HBUAAKgKRpABAAAAAFDPFI7SaNeuXYW/vD906JCmT5+uzz//XG6325fh1bh+/fopMjJSl156qf7whz+Q0AAAoA5jpAYAAAAAAPXM1q1bJVV86inDMLRgwQJJnjU1zOa6/Qyk0+lUcnKyevToIUkKCQnRPffcI4vFV6sOAACAmkJSAwAAAACAeuamm25ScnKyunTpUqHyO3fuVEpKiiwWi0aMGOHj6Hzr2LFjmjt3ro4cOSLDMNSzZ09JIqEBAEA9QVIDAAAAAIB6JiQkRP369atQWZfLpYULF0qSBg4cqMaNG/swMt8xDEPr1q3TDz/8IKfTqZCQEKaZAgCgHiKpAQAAAABAA7Zu3TqlpaUpJCREQ4YM8Xc4VZKXl6f58+d7p91q166drrzySjVq1MjPkQEAgOpGUgMAAAAAgHoiNTVVixYtUu/evdW7d+8zls/Pz9eyZcskScOGDVNQUJCPI6x+e/fu1dy5c5WdnS2z2ayRI0fqvPPOk8lk8ndoAADAB0hqAAAAAABQT2zevFn79u1TVFRUhZIax48fl8ViUZMmTdS3b98aiLD6OZ1OZWdnq0mTJho/frxiYmL8HRIAAPAhkhoAAAAAANQDbrdbycnJkqSEhIQKHdOyZUvde++9yszMrFMLaTudTlmtnq802rdvr6uvvlodOnRQQECAnyMDAAC+ZvZ3AAAAAAAA4Ozt2bNHubm5CgkJUdu2bSt8XEBAgJo2berDyKrXpk2b9Oqrryo9Pd27rVu3biQ0AABoIEhqAAAAAABQDyQlJUnyfMF/plEXhw8f1saNG2UYRk2EVi3y8/P1xRdfaN68ecrOztaqVav8HRIAAPADpp8CAAAAAKCOczqd2rp1q6QzTz1lGIZ+/PFHpaSk6Pjx4xoxYkRNhHhW9u/fr7lz5yojI0Mmk0nDhg3T0KFD/R0WAADwA5IaAAAAAADUcTt37lR+fr7Cw8MVGxtbbtkdO3YoJSVFFoul1i8O7na7tXLlSi1btkyGYSgiIkLjx49XmzZt/B0aAADwE5IaAAAAAADUcSEhIerYsaOaN28uk8lUZjmXy6WFCxdKkgYOHKiIiIiaCrFK1q5dq6VLl0ryjEAZM2aMgoKC/BwVAADwJ5IaAAAAAADUcXFxcYqLizvjGhnr1q3T8ePHFRISoiFDhtRQdFXXp08fbdmyRb169VLPnj3LTdgAAICGgYXCAQAAAACoJ8r70j8/P1/Lli2TJA0bNqxWjngoKCjQypUr5Xa7JUkWi0U33XSTevXqRUIDAABIYqQGAAAAAAB12pYtW9SqVSs1bty43HIrV65Ubm6umjRpUivX0jh8+LDmzp2rtLQ0ORwOXXDBBZLKT9QAAICGh6QGAAAAAAB1VG5urr744gu53W7df//95SY2OnbsqD179mjIkCGyWCw1F+QZGIahxMRELV68WC6XS2FhYYqLi/N3WAAAoJYiqQEAAAAAQB21detWud1utWjR4owjNWJjY3XrrbfWTGAVdPLkSX311VfatWuXJKlz5866/PLLFRIS4ufIAABAbUVSAwAAAACAOiopKUmSlJCQUGYZwzC8UzjVpqmc9u7dq88++0w5OTmyWq0aPXq0+vXrV6tiBAAAtQ9JDQAAAAAA6qCsrCylpKRIKjupYRiGPvnkE7Vo0UKDBw9WYGBgDUZYvtDQUBUUFKhZs2YaP368mjVr5u+QAABAHUBSAwAAAACAOmjLli2SpDZt2igiIqLUMjt37tTOnTu1e/du9enTx+9Jjby8PAUHB0uSoqOjNWnSJMXExMhms/k1LgAAUHeY/R0AAAAAAACovDNNPeV2u7Vw4UJJ0sCBA8+45oYvGYahtWvXatq0adq7d693e2xsLAkNAABQKYzUAAAAAACgjsnJydGxY8dkMpnUvXv3UsusW7dOaWlpCg4O1pAhQ2o4wt/l5eVp/vz52rp1qyRpw4YNiouL81s8vrbV3wEAQD3E31YURVIDAAAAAOog05MsplxfGFONSh8TGhqqP//5z9q/f79CQ0NL7M/Pz9eyZcskScOHD1dQUNDZhlklKSkpmjdvnrKysmQ2mzVy5Eidd955fonF16KjoxUSFKRJdru/QwGAeikkKEjR0dH+DgO1AEkNAAAAAADqoICAALVr167UfStXrlROTo6aNGmivn371nBkksvl0vLly7VixQpJUlRUlMaPH6+WLVvWeCw1JTY2Vlu3b1daWpq/QwGAeik6OlqxsbH+DgO1AEkNAAAAAADqELfbLbO57CUyCwoKtGbNGknShRdeKIvFUlOheW3fvt2b0OjVq5cuueQSBQQE1HgcNS02NpYv3AAA8DGSGgAAAAAA1CFLly7Vjh07NHz4cHXt2rXE/oCAAN1xxx3atGmTOnfu7IcIpa5du6pXr17q0KFDmWt+AAAAVEXZj3YAAAAAAIBaxTAMJSUl6ejRo3K5XGWWa9y4sc4//3yZTDWz9kp+fr5+/PFH2U+tJ2EymXTFFVeQ0AAAANWOkRoAAAAAANQRBw4cUEZGhmw2W4lRGIZh6OjRo2revHmNxzR37lylp6fr5MmTGj9+fI22DwAAGhaSGgAAAAAA1BGbN2+WJHXp0kU2m63Yvp07d+qTTz5Rz549dcUVV/h8lIbb7dbPP/+sZcuWye12KyIiQv379/dpmwAAACQ1AAAAAACoA9xut5KTkyVJCQkJJfYtXLhQkhQWFubzhEZWVpbmzZunlJQUSVL37t01duxYBQUF+bRdAAAAkhoAAAAAANQBe/fu1cmTJxUUFKT27dsX27du3TqlpaUpJCREQ4YM8Wkc+/bt0yeffKK8vDzZbDZdeuml6tmzZ42t3wEAABo2khpAQ2MLkUKipdw0yZHr72gAAAAAVFDh1FPdunWTxWLxbs/Pz9fSpUslScOGDfP5aIkmTZrIarUqJiZG48ePV5MmTXzaHgAAQFG1Jqlht9sr/MHriy++0GWXXeadPzQlJUVpaWnq16+fL0ME6g5rkNT1Kim6s5RzTNo6T8o+IDXvIXW5UrKnexIbyXOlI5v8HS0AAACACujevbscDod69OhRbPvKlSuVm5urJk2aqG/fvj5pOyMjQxERETKZTAoJCdGNN96oyMjIYskVAACAmmD2dwCStHbtWsXHxystLe2MZTdt2qTx48dr9erV3m1ff/21rr32WhUUFFSp/d27dysxMVF2u71KxwO1TrcJkiVASnxVOrhG6nWjFNBI6nyZtOYt6Zfp0tYvpQ4X+ztSAAAAABXUvn17jR8/XnFxcd5tmZmZSkxMlCRdeOGF1Z5kMAxDiYmJeu2117Rx40bv9ujoaBIaAADAL/yS1MjOzlZWVpby8vJkt9v1yiuvaOzYsQoLC5Pdbpfdbldubq5OnDhR4tg5c+aob9++GjRokAzDkCTdfffd6ty5s3bu3OktV7jvTP70pz9p4MCBuuWWW9S2bVvvomtAnRUUKTXt6hmFkXdc2p8ouV1Sk47Sjm+lnCOecicPSbZg/8YKAAAA4Kykp6crKChIcXFx6ty5c7XWnZOTo48//lg//vijXC6Xfvvtt2qtHwAAoCr8Mv3UPffco88//1wWi0VOp1MOh0NWq1UzZ85URESEJMnpdMput8vpdHqPKygo0Ntvv60HH3xQycnJ6t27txo1auRdjGzYsGGSJLfbrb59+2rhwoXlxrFkyRL9+OOP2r17t8LCwnTrrbfq+eef1wcffOCjMwdqQOM4KS9dKsj+fdv+RCn3uJS51/PeZJbihkpHt/gnRgAAAAAVVlBQoJUrVyohIUHNmjUrti8+Pl733Xef8vLyqnWh7l27dunLL79UTk6OrFarRo8ezZTPAACgVvBLUmPWrFmaNWuWcnNzNWLECD3xxBMKDQ3VxIkTdfjw4TKPmzFjho4eParGjRure/fupU43lZOTo9DQ0ArFERISohkzZigsLEyS1LNnTy1atKjM8vn5+crPz/e+z8rKqlA7QI0KDC+e0JCkvT/9/ntYC6nv7Z7RG6teqtnYAAAAAFTajh07tGLFCiUlJem+++4rkbwICAhQQEBAtbTldDq1ePFi75RWzZo10/jx40skUwAAAPzFb2tq5Obm6oYbbtDjjz+uMWPGKCgoSIGBgd79DodDubm53vdpaWl66qmnFB8f7902f/58TZkyxfs+Ly9PkZGR+uyzzyoUw8CBA72jO44ePaqZM2fqqquuKrP8s88+q4iICO+rTZs2FT1doOaYLVJ506+dPCyte8czDVW3CTUXFwAAAIAqSUpKkuRZKLwwobF7925t3LixwlMvV9TBgwe9CY3+/fvrtttuI6EBAABqFb8lNYYMGaIvvvhCl112mWw2m84//3ylpqYqKCjIm+Do06ePt/xbb71VLAkhSZGRkXr99de9IzaSkpLkdrs1cuTISsXy9ttvKzY2VjExMbr55pvLLPfoo48qMzPT+9q3b1/lThqoCQ57ybUy+t0ptTr39/fZh6Qtn3vW3rAG1Wx8AAAAACosLy/Pu37kOeecI8kz5fL333+vL7/80puAqC6xsbEaMWKEJk6cqEsvvVQ2m61a6wcAADhbfktqvPrqq9q4caMKCgrkcDj0v//9T3Fxcd6Fwt1ut/dpFEl64IEH9OabbxarY/DgwQoPD/dOGbVmzRqde+65ioqKqlQsN954o7788ktt27ZNr7zySpnlAgMDFR4eXuwF1DrZB6WQaMny+8gnBUdK9gypwyW/bzPcp35W75NdAAAAAKrPtm3b5Ha71axZM++IiXXr1iktLU3BwcHq3bv3WdWfl5enefPm6cSJE95tQ4cOrfZFxwEAAKqLX0dq9OjRo9ynPqzW35f8CA0NVcuWLYvtN5lMuuyyy/Ttt99KklavXl3pURqSJ1lx8cUX6+mnn9Z7771X6eOBWiVzr3TyiNR1nCeZ0fYCyWSRTh6SWg+QWvWXAiOkDhdLx3dJrvwz1wkAAADALwof9ktISJDkWetx2bJlkqThw4crKKjqI69TUlL05ptvatOmTfryyy+rfSorAAAAX6jxhcLtdruOHDkim80ms/n3nMrx48flcrmKLRTudrtVUFCgli1blrno2YgRI/R///d/kqQVK1bonXfeqXAs//73v9WiRQtdf/31kjxJFIvFUpXTAmqXjbOkrldJAx+Uco5KG96X8rOkTR9LncZIHS+Vju+Utszxd6QAAAAAynDy5Ent2bNH0u9JjZUrVyonJ0dRUVHq27dvlep1uVxavny5VqxYIUmKiorSxRdfXGIBcgAAgNqoxpMaa9eu1fDhwxUYGFhsJIbL5VJOTo66dOni3eZ0OpWfn681a9aoZ8+exepxu90ym80aOXKkXnnlFaWkpGj//v0aOHBghWPp2LGjbrvtNrVs2VItW7bU888/r4kTJ579SQL+lp/lSWSc7sROKXFaTUcDAAAAoAqOHTumwMBANWnSRJGRkcrMzPSuoTFq1KgqPZSXnp6uL774Qvv375ck9erVS5dcckmZDxICAADUNjWe1Bg8eLAcDkeJ7atXr9bVV1+tvXv3lnu8w+GQ2+3W9ddfrzlz5nifJDEMQ263W2FhYZI8SY/du3crPj6+zLouv/xyPfLII7ruuuvkdDp12223eUd9AAAAAADgT23bttWf//xnZWdnS5KWLl0qp9Op2NjYKq15cejQIX3wwQfKz89XYGCgxo4d6x0BAgAAUFfUeFKjLPn5+bLb7Wcsl5WVJYfDoVmzZmn27NnFprAqyul0VuiplUceeUSPPPJIpeMFAAAAAMDXLBaLGjduLEnq3bu30tLSNHr06CpNFdWsWTM1adJEFotFV111lbdeAACAuqTWJDWGDh2qI0eOnLHc/PnzK1Rf0amtAAAAAACoS06ePKnQ0NBiyYu4uDjdeuutlUpoHD58WE2bNpXFYpHFYtF1112n4ODgMh8QBAAAqO34FAMAAAAAQC3z0Ucf6dVXX9WBAwdkGIZ3e0UTGm63WytWrNDbb7+tZcuWebeHhoaS0AAAAHUawxkAAAAAAKhFjh07piNHjshsNqtx48Z6++231bFjRw0ePLhCC3pnZWVp3rx5SklJkSRlZGTIMIwqTVkFAABQ25DUAAAAAACgFklKSpIkdejQQVu3btWhQ4eUkZGh884774zHbtu2TV9//bXy8vJks9l06aWXqmfPniQ0AABAvUFSAwAAAACAWsIwDG9So3PnzlqyZIkkafjw4QoKCirzOIfDoR9//FFr166VJMXExGj8+PFq0qSJ74MGAACoQSQ1AAAAAACoJQ4dOqQTJ07IarXq+PHjysnJUVRUlPr27VvucVlZWdq0aZMkadCgQRoxYoQsFktNhAwAAFCjSGoAAAAAAFBLFI7SaNeunVavXi1JGjVq1BkTFE2aNNHll1+ukJAQtWvXzudxAgAA+IvZ3wEAAAAAAADP1FNbtmyRJBUUFMjpdCouLk6dO3cuUTYnJ0effPKJdzFwSUpISCChAQAA6j2SGgAAAAAA1BLjxo1Tr169tG/fPkmeURqnL/K9a9cuvfHGG9qxY4fmz58vt9vtj1ABAAD8gumnAAAAAACoBUwmk+Lj4xUfH69hw4Zp586datWqlXe/0+nU4sWLlZiYKElq2rSpJkyYILOZ5xUBAEDDQVIDAAAAAIBapnHjxurfv7/3fVpamubOnavDhw9Lkvr3769Ro0bJZrP5K0QAAAC/IKkBAAAAAICfpaSkKDk5Wa1atVLPnj2L7Tt+/LhmzJghh8Oh4OBgXXHFFaWuswEAANAQkNQAAAAAANQ4i8kil+Hydxi1xvr167Vp0yb9+uuv2r9/v8aMGePdFxUVpY4dOyovL0/jxo1To0aN/BgpAACAf5HUAAAAAADUqABLgJbcuETf7fpOz6x4xt/h+J3D4dC2bdu876Ojo5WamqqmTZsqODhYJpNJV1xxhWw2W4lFwwEAABoaVhMDAAAAANSoAleBpiyZogfOfUD/Hv1vf4fjdzt37lRBQYEkKTIyUidPntT777+vb775RoZhSJICAgJIaAAAAIiRGgAAAAAAP1i+d7lGzhqp/936P/168Fd9mvRpmWWdTziVmZ8pt+EudX+ILURztszR5K8m+ypcn1q/fr33d7PZrJUrV0ryJDLcbrcsFou/QgMAAKh1SGoAAAAAAPxi89HNWvDbAj1/4fP6PPlzOd3OUsvlu/I14O0B+i39t1L3Tx02Va3CW/kyVJ8JVKB+++338zp+/LgCAwM1duxYJSQk+DEyAACA2onppwAAAAAAftE8tLlGth0pp9up68+5vsxyBa6CM9blctfNRccHaZB3iilJatOmje68804SGgAAAGVgpAYAAAAAwC8eHfqovtz2pdYfXq8/nfsnfbDxA3+HVOOCFez9fdiwYTr//PNlNvP8IQAAQFlIagAAAAAAalznJp31xz5/1KB3B2lP+h49dcFTurjDxfph1w/+Dq1Gfafv9Mr1ryg/P1/du3f3dzgAAAC1HkkNAAAAAECNMpvMeufyd/T+xve14fAGSdIba97Qvy78l5alLJPdafdvgDWsQ4cO/g4BAACgzmBMKwAAAACgRr0w6gW1CW+jRxc96t323Mrn1CKshWZePlNmE7eqAAAAKB2fFAEAAAAANeapC57Srb1v1dhPxiozP9O7PcOeoclfTdY13a/R1xO/VnRItB+jBAAAQG3F9FMAAAAAAJ+LjYjVG2Pe0JDYIbri0yuUdDSpRJlvd36rG+fdqA+u/EAb79yo7q93V4Y9QzazTatvXy234S617hBbiGZvnu3rUwAAAEAtQFIDAAAAAOBz2fnZCrQEauh7Q7XpyKYyy32S9In2Ze1TXEScMuwZkqRAa6B6vtlTv6X/VuoxU4dNVdvGbX0RNgAAAGoZkhoAAAAAAJ9Lt6frwg8vrFDZlakrtVIrve9tT9vKLf/k8ifPKjYAAADUHaypAQAAAAAAAAAA6gSSGgAAAAAAAAAAoE4gqQEAAAAAAAAAAOoEkhoAAAAAAAAAAKBOIKkBAAAAAAAAAADqBJIaAAAAAAAAAACgTiCpAQAAAAAAAAAA6gSSGgAAAAAAAAAAoE4gqQEAAAAAAAAAAOoEkhoAAAAAAAAAAKBOIKkBAAAAAAAAAADqBKu/AwBqi62px/0dAs4S/xsCAAAAAAAA9RtJDTR40dHRCgkJ1qTn5vs7FFSDkJBgRUdH+zsMAAAAAAAAAD5AUgMNXmxsrLZu3aa0tDR/h4JqEB0drdjYWH+HAQAAAAAAAMAHSGoA8iQ2+CIcAAAAAAAAAGo3FgoHAAAAAAAAAAB1AkkNAAAAAAAAAABQJ5DUAAAAAAAAAAAAdQJJDQAAAAAAAAAAUCeQ1AAAAAAAAAAAAHUCSQ0AAAAAAAAAAFAnkNQAAAAAAAAAAAB1AkkNAAAAAAAAAABQJ5DUAAAAAAAAAAAAdQJJDQAAAAAAAAAAUCeQ1AAAAAAAAAAAAHUCSQ0AAAAAAAAAAFAnkNQAAAAAAAAAAAB1AkkNAAAAAAAAAABQJ5DUAAAAAAAAAAAAdQJJDQAAAAAAAAAAUCeQ1AAAAAAAAAAAAHUCSQ0AAAAAAAAAAFAnWP0dQF1mGIYkKSsry8+RAAAAABVT+Nm18LMsAAAAANQlJDXOQnZ2tiSpTZs2fo4EAAAAqJzs7GxFRET4OwycBWMqiSkAAAA0PCaDR7SqzO126+DBg2rUqJFMJtNZ1ZWVlaU2bdpo3759Cg8Pr6YI6y/6q/Los8qjzyqH/qo8+qxy6K/Ko88qryH0mWEYys7OVsuWLWU2MxstAAAAgLqFkRpnwWw2q3Xr1tVaZ3h4eL29gfYF+qvy6LPKo88qh/6qPPqscuivyqPPKq++9xkjNAAAAADUVTyaBQAAAAAAAAAA6gSSGgAAAAAAAAAAoE4gqVFLBAYGaurUqQoMDPR3KHUC/VV59Fnl0WeVQ39VHn1WOfRX5dFnlUefAQAAAEDtxkLhAAAAAAAAAACgTmCkBgAAAAAAAAAAqBNIagAAAAAAAAAAgDqBpAYAAAAAAAAAAKgTSGoAAAAAAAAAAIA6gaQGAABAHXX8+HH973//U1pamr9DAQAAAACgRpDUqEZJSUnq37+/IiMj9cgjj8gwDEnShx9+qNjYWIWFhenCCy9USkpKpep1OBw655xztGzZMu+25cuXq2vXroqOjtZLL71UjWdRc8rqr/fee08JCQlq3Lixrr322gp/UTNjxgzFxMTIZrNp9OjROnTokHdffeivQsePH1fbtm2L/Tsqqy/PpLx+qS99Vp39Vai+XpOFSuuz8raXpyFfl1999ZXatWsnq9Wqc889V1u3bq1QXQ31uqxqfxVqiNflp59+qg4dOuiee+5RbGysPv300wrV1RCuyzP9vbr44ov1/vvvV6iuhnBNAgAAAEBdQlKjmuTn5+uyyy5T3759tWbNGiUnJ+v999/Xb7/9pilTpujLL79UcnKy4uLidPPNN1eq7n/9619KSkryvj927Jguv/xyXXvttVq1apVmz56tpUuXVvMZ+VZZ/bVo0SL96U9/0ssvv6yNGzcqKytL48aNO2N9K1eu1BNPPKEPP/xQe/bskd1u15///GdJ9aO/CqWlpWns2LHFvqQpqy/PpLx+qS99Vp39VVR9vCYLldZn5W0vT0O+Ln/77TdNnjxZzz33nA4cOKC4uDjddtttZ6yroV6XVe2vohradZmRkaH77rtPK1as0Pr16/XWW2/pL3/5yxnragjX5Zn+Xs2ePVs//vhjhepqCNckAAAAANQ5BqrFvHnzjMjISCMnJ8cwDMPYsGGDMXjwYOOzzz4zrr76am+5FStWGDExMRWud8eOHUbjxo2N+Ph4Y+nSpYZhGMbLL79sdO7c2XC73YZhGMaXX35pXH/99dV3MjWgrP664YYbjAceeMBbbsuWLYYkIy0trdz63nnnHWPu3Lne9++++67RqVMnwzDqR38VGjlypDFt2jRDkrFnzx7DMMruyzMpr1/qS59VZ38Vqq/XZKHS+qy87eVpyNfl/PnzjTfeeMNbZsmSJUZAQMAZ62qo12VV+6tQQ7wuU1NTjY8++shbZuPGjUajRo3OWFdDuC7L+3t1/Phxo3nz5kbnzp2N995774x1NYRrEgAAAADqGkZqVJONGzdq4MCBCgkJkST16NFDycnJ6tatm5YsWaL169crMzNT//nPfzRq1Khixy5btkyNGzcutd477rhDf/3rXxUXF1esrREjRshkMkmSBgwYoHXr1vnmxHykrP5KS0tTbGyst5zFYpEkWa1W77bS+uvWW2/VVVdd5X2/fft2dejQwdtWXe+vQjNmzND9999fbFtZfVlUaX1WXr/Ulz6rzv4qVF+vyUKl9Vl52wtxXRbvm7Fjx+rOO+/0vi967oW4Ln9X1f4q1BCvyzZt2uj666+X5Jl668UXXyx2vUkN97os7+/Vww8/rHHjxmngwIEl9jXUaxIAAAAA6hqSGtUkKytLbdu29b43mUyyWCyKiYnRhAkT1KdPHzVu3Fi//PKLXnzxxWLHDhkyRHv37i1R53vvvafMzEw9/PDD5bYVHh6uAwcOVPMZ+VZZ/RUXF6evv/662PoaAwYMUEREhLdsWf1V6Pjx43rrrbd09913l9pWXeyvQu3atSuxray+TE9P924rrc/K65f60mfV2V9S/b4mC5XWZ+VtL8R1WbaCggK9+OKL3nMvxHVZusr0l9Swr0vJ88V68+bNtWDBAk2bNq3YvoZ6XZbVX0uXLtXixYv1/PPPl7q/oV6TAAAAAFDXkNSoJlarVYGBgcW2BQUFKTk5WfPnz9cvv/yi7OxsXXvttbr00kuLLUxstVqLfWkveeZpfvTRRzVz5sxioxRKaysoKEi5ubk+OCvfKau/Hn/8cRUUFKhv374aNGiQnn/+ed17770ljj29v4q6++67NWjQII0ZM6bUtupif5WnrL4seo6l9Vl5/VKf+6yq/VXfr8mzxXVZtscff1xhYWH64x//WGw712XpKtNfXJee0WaLFy9W9+7dNXny5GL7uC5/Z7fbdccdd+iNN95QeHh4qWW4JgEAAACgbrCeuQgqIioqqtgCpZKUnZ2td955RxMnTtSAAQMkSf/4xz/05ptvauPGjerVq1eZ9T3wwAO69dZbSy0TFRWlY8eOFWsnICCgWs6jppTVXwEBAfr555+1a9cuvfjii0pPT9d1111X4Xrfffdd/fTTT9qwYUOxtup6f5WnvL4803Fl9Ut97rOq9ld9vyZ9qSFel4UWLlyoN998U4mJibLZbGcs31Cvy0KV7S+uS89os969e+v9999XXFyc0tPTFRkZecbjGtp1+fTTT6t///7eBE5FNfRrEgAAAABqI0ZqVJP+/fsrMTHR+z4lJUX5+fkKCwvTkSNHvNuzs7OVk5Mjl8tVbn0ff/yxpk+frsaNG6tx48ZauXKlxo4dq+eee65EWxs2bFCrVq2q/6R8qKz+ioqKkiS1bNlSX3zxhZ599lnvuhpnsnr1aj3wwAP69NNP1bx58zLbqov9VZ4z9WVFjyvaL/W5z6raX/X9mvSVhnpdStLu3bt1/fXX64033lC3bt0qdExDvS6lqvVXQ74ulyxZokceecT7vnCkitl85o92DfG6/Pjjj/XVV195/618/PHHuvvuu0tMc3a6hnxNAgAAAECt5e+VyusLh8NhNG3a1Pjggw8MwzCMO+64wxg7dqzxySefGMHBwcZLL71kzJ4927jggguM2NhYo6CgoNixGRkZxerbs2dPsde5555rfPLJJ0Z6erpx7NgxIygoyFiyZInhcDiMMWPGGPfee2+Nnu/ZKqu/Cj333HPG0KFDyzz29P46fPiw0axZM+Mf//iHkZ2d7X0ZhlEv+ut0kow9e/YYhnHmviwsc3qfldcv9a3PqqO/6vs1ebqifVaR7VyXxfsmNzfX6Nq1q3H77bcXO3e32+0tz3V59v3VkK/LAwcOGI0aNTLeeustIzU11bjxxhuNiy66qFj5hn5dFu2vffv2Ffu3Mn78eOOFF14wjh075i3f0K9JAAAAAKgrSGpUo3nz5hnBwcFGs2bNjCZNmhhJSUmG2+02/v73vxuxsbGGzWYzevfubaxZs6bYcUuXLjUiIiLKrXvYsGHG0qVLve//85//GDabzYiOjjbi4uKMw4cP++CMfKu0/jIMw0hPTzeioqKM1atXl3pcaf318ssvG5JKvArVh/4q6vQvlsvqy0Jl/Rsrr1/qU59VV38VVR+vyaIqm9TguizeN/PmzSv13Iv2Hddl9fRXUQ3tuvzhhx+Mrl27Go0aNTImTJhgHD16tFj5hn5dlvX3yjAM46abbjLee++9Ytsa+jUJAAAAAHWFyTCKrFiNs3bgwAGtWbNGgwYNUtOmTX3a1q5du7R161YNGzaszEUvazv6q/pUtS/L65f63Ge++LdXn/vLV+iz0jXU69IX6K/Ko89K4poEAAAAgNqDpAYAAAAAAAAAAKgTWCgcAAAAAAAAAADUCSQ1AAAAAAAAAABAnUBSAwAAAAAAAAAA1AkkNQAAtd4rr7yiF154QZLkcDiUl5cnl8vl56gAAAAAAABQ00hqAABqjSeffFLjx48vsf2cc87RlClTtHr1av33v/9V06ZNFR0dXewVEBCgN9980w9RAwAAAAAAoKaQ1AAA1IhmzZoVS0K88847JcpYrVZZrdYS20eMGKHrr79eJ06c0KRJk3Ty5Emlp6crLS3N+xo9erRsNltNnAoAAAAAAAD8hKQGAKBGZGZmKjExUWlpaRo4cKBcLpdycnLkcDjkdrslSTabTRaLRfn5+XI4HJKkgQMHasmSJXrvvfd08cUXl9uGxWLx+XkAAAAAAADAf0o+DgsAgA+UNoqiadOm3tEZJpNJdrtdTqdT33zzjV5//XVNmjRJGRkZ3vJ9+vRRVlZWsTruvPNO/fnPf/Z1+AAAAAAAAKgFSGoAAGqEyWQq9j4gIEC5ubnFtr344ovasGGDPvroI+82q9Uqs9kzsHD//v1avXq14uPjJUl//etflZ2d7dvAAQAAAAAAUGsw/RQAoEZYLBYNGDBA0dHRWrBggUwmkwoKCrRgwYIK11GY3Cjq9GQJAAAAAAAA6i+SGgCAGuF2u7V69Wrvot6SlJGRoVtuuUWfffZZhesZPny4OnTooA4dOuitt97yVbgAAAAAAACohUhqAABqhMvlKvbeMAw1a9ZM06ZN06efflrhepYtW6Zdu3Zp165duuOOO6o7TAAAAAAAANRiJDUAADXC5XIVm36qMMkxYcIEzZ07t8J1nM4wjGqNEwAAAAAAALUXC4UDAGqE0+nU6tWr1aFDB40dO1YFBQWVrqN169a68MILi2278847qytEAAAAAAAA1HIkNQAANSImJkZWq+c/O++++66Cg4NLlMnOzi6x8Hdubq6cTqckaf369aXWbRiGjh07ppCQkGqOGgAAAAAAALUJSQ0AQI3Yt2+f9/dmzZoV25eTk6MBAwZo586deu2114rtO3nypOx2e5n1Hjt2TG3btlXr1q01dOjQ6g0aAAAAAAAAtYrJYDJyAEAtsGvXLjVt2lQRERGVPvbgwYNq2bKlD6ICAAAAAABAbUJSAwAAAAAAAAAA1AlmfwcAAAAAAAAAAABQESQ1AAAAAAAAAABAnUBSAwAAAAAAAAAA1AkkNQAAAAAAAAAAQJ1AUgMAAAAAAAAAANQJJDUAAAAAAAAAAECdQFIDAAAAAAAAAADUCSQ1AAAAAAAAAABAnUBSAwAAAAAAAAAA1AkkNQAAAAAAAAAAQJ1AUgMAAAAAAAAAANQJJDUAAAAAAAAAAECdQFIDAAAAAAAAAADUCSQ1AAAAAAAAUO1Onjzp7xBqFZfL5e8QAKBeIKkBALXEP/7xD+3atatSx2RnZ5e6PTMzs0ox5OTkaMOGDSW2OxwObdiwQVlZWVWqtzLy8vL03nvvafv27T5rIykpyWd1+8KWLVtkGIa/wwAAAAAqdd/y5z//WRdeeKH3fVZWlvLz88ssn5GRodzc3CrHdt999+n7778vtm3u3Lmy2+2lln/llVc0ZsyYKrd3uscff1xz5swpsd0wDF100UX661//6t128uRJ5efny+12V7qdon1oGIZ++umnKt0Dvvbaa3ruuedUUFBQ6WMBwJ9IagBALfDrr7/qiSee0MqVKyt13KRJk3TRRRcV+xC6ePFitWrVqkJJgaNHj2rx4sV6+umnNWzYMEVFRal///7avHlzsXJpaWnq3bu3EhMTi21/8803ZTKZKvz65ZdfzhiTzWbTI488ojfffLOCvVA5P/74oy688EKlp6f7pH5f+NOf/qSpU6f6OwwAAAA0cJW9b9m+fbt69+7tfd+tWzcFBQWVeb8QGRmpBQsWSJJeeOEFjR07VhMmTCjxGjdunF544YUS7X344YfF7oPS0tJ022236Y9//GOp8WVkZGjLli2V6YJyffnll1q/fn2J7SaTSVdffbX+/e9/67vvvpMkNW7cWEFBQbJYLKX2xen3XoXcbrcGDBjgPf/c3FxdddVVev311ysd7/Tp07V06VIFBARU+lgA8CeSGgBQw9LS0rRhwwZt2bJFW7du1bZt2/Tcc8+pW7duGjhwoLZt2+Z9JScna8OGDTp27FiJevLy8rRw4UK1bt262IfQ888/X61atdL9999fZgxOp1NxcXFq3ry5rrzySv3zn/+UYRh68803tWrVKrVr165Y+aCgIEmehENRNptNsbGxysvL875efvnlEtsKbxQK6ykaa+PGjdW8eXO1aNFCLVq0UOvWrZWVlaXXX3/du61FixZq3ry5IiMjdfvtt1euw4s4ePCgbrzxRn3xxReKjIwsti8vL0/t2rXTvffeW+bxf/3rXxUTE1PmCJnSvP/++2XetN18881yu92aOHGiWrZsWezm8D//+Y/3908//VSzZ8/23gABAAAAvnY29y1LlizRjBkztGHDBuXn5+vtt9/W3LlztXnzZp08eVLvvvuuhg4dqry8PA0dOlTvvvuucnJylJmZqUsvvVSS1LlzZ51//vkaNmyY9u7dq9DQUA0fPlzDhg3ToEGD1LFjR+3atUt///vfvSPKrVarwsPDvecQHR2tTz75RB999JFeeumlEudotVoVERFRZh/89NNPpX6OL+3+TPLcH51+z1Totttu0yWXXKJNmzZJkrZt26Y9e/bowIEDOnTokPe1evVqSSoz0TB37lxt2rRJgwYNkiSFhobq0Ucf1fPPP699+/aVekxubq5Onjwph8Ph3bZo0SLt2LFDTzzxRInyhmHI4XDUyEh9AKgKq78DAICG5ttvv9Xtt9+ugIAAmc1mFRQUKD8/XxERERo4cGCxsk6nUwUFBXrjjTd06623Fts3e/Zs5eXl6fbbb9eRI0d0+PBhBQYGSvJ8YM7OzlZycrLMZk/+Oj8/XwkJCbJYLLJarZo3b57Cw8PVvn179e/fXyNGjNDkyZO99WdmZurZZ5/VzTffrBYtWkjyPGFUlNVqlclkKpasKG1b4Qfy0z/gz507V3l5eYqJifHuu+mmmxQWFqbXXnutWHv5+flat26dunTpUoneLu7Pf/6z/vjHP3pvAIp66qmnlJ2draeffrrUY5OSkvTSSy9p5syZatSoUYXbvOyyy/Trr78W21ZQUKBLL71Uffr00S+//KINGzbo/vvv1z//+U99//33SktL04EDB7zlmzZtqrfeekt33XWXRo4c6f3fGQAAAPCVs7lv+f777/XRRx8pKytLX3/9tebMmaOEhASNHz9ekue+wGw2KygoSGazWTabTSEhIcXqvPzyy3X55ZcrPT1djz/+uAICAvTee+/p119/Ve/evRUQEKBly5bpySef1COPPOI9rvD+p9DFF1+sP/3pTzpy5EiJczSbzQoODi6zD6xWz9dmq1atUuvWrbVs2TLdcMMNcjgc+u2332Sz2WSxWGQ2m2UymeR2u5WTk6O9e/cqJCRETZs21Zw5c/TYY49p06ZN+vbbb711d+jQodQ2C6fKKi2pUVBQoL///e+68sorNXjwYO/2++67T++8845uuukmLVy4UBaLpdhxd999tz744INS2xs6dGiZ5y95Hv46/eE0APA7AwDgN3l5eUb37t2NRx55xDAMw5g6daqxcOHCCh17zjnnGM2bNzcMwzCmTZtmBAYGGhEREaW+wsPDjaCgICM9Pb3Uuvr27WtMnTq12LZDhw4ZkoyFCxca6enphiRj6dKlxcrMmjXLiIuLK7Zt+vTpJbbt3LnTkGRs3bq12PZ3333XaNasmbFgwQLDMAzjyy+/NJo3b278+uuvxm+//Wb07dvXWLVqleF0Oo277rrLCAsLM3777bcK9c/p9u3bZ0RFRRm5ubkl9iUlJRk2m8146623Sj3W7XYbgwcPNgYNGmS43e4qtV/UG2+8YbRu3dqw2+3G7Nmzjeuuu87Yvn270blzZ8MwDOPZZ58t9Twvuugi49NPPz3r9gEAAIDKqMp9y4wZM4x+/fqVuu/DDz80hg0bZhiGYQwbNsz48MMPy6znhhtuMLp162acOHHCOHz4sBEcHGxMmTLFMAzDWLFihSHJcLlchmEYRpMmTYz33nuvRB2F+59++mkjOjraiImJMVq1amWEh4cbAQEBRqtWrYyWLVsaLVq0MKKiooxNmzYZhmEYq1evNiQZe/bsMQzDML7//ntDkjFv3jzDZDIZVqvVCAoKMkJCQoyQkBDDbDYbVqvVsFgsxj333GMYhmF8/vnnhiTD4XAYhmEYOTk5RnZ2dolXXl6eYRiGsWfPHkOSsXnz5hLn8Ze//MUIDAw0du7cWWLfL7/8YgQEBBg33XST4XQ6i+07cOCAsWPHDmPv3r3GoUOHjDfeeMOwWCzGsmXLjOTkZOPll182tm/fbhw6dKjECwBqI0ZqAIAf3X777WrZsqWeffZZSdKMGTMUGhpabDG90nz55ZfavHmz2rdvL0m6//77y51uqrTjP/nkE+/oiD179uiLL77Qrl275Ha7ZbfbNWPGDEm/P51UGpPJpL179xZ7csflcsnpdBbbZpSxyPXNN9+sgwcP6vHHH9fevXt177336o477tCaNWv02muvKTY2Vp07d9Yjjzyi+fPna9myZSWmxqqoL774QldccUWJJ7EMw9Cdd96pc845R7fddlupx77zzjtatWqVfv311xKjVSqroKBAzzzzjJ544gkFBgbK7XbLbDbLbDbL5XLJ4XBo//79pZ7ntddeq88++0x/+MMfzioGAAAAoDKqct+ycOFCjRw5Ul27dtVLL72kSy65RO3bt9fu3bu9ZQo/Wy9fvlw33HCDJGnLli3q1q2bMjMz9dhjj+mbb77Rr7/+6p0+9qmnntKjjz6qK664wlvP6aMzJHnvawICArwjF6688kqdc845slqtMpvNevrppxUSEqKHH35Ykryfx9u0aVNmvZI0atSoUhf47tevn8aOHau///3v3nugwlHWhfdVvXr10s6dO0sce8011+i///1vmf25bNkyvfjii3rhhRdKHeUxYMAAzZo1S5MmTdLBgwc1a9Ys74j7li1bestlZmbqH//4h+677z4NGzZMW7Zs0YMPPqgrr7zSWx4AajvW1AAAP8jNzdWtt96qX3/9VXPmzPF+yA4MDCyWRHA4HMrJySn2gdlut+v//u//SqwJ8f333+vf//53sW2rVq1SXFyc5syZU2x7dHS0EhIS1L17d3Xs2FHp6elq1qyZEhIS1KVLF3Xt2rXMD/BFGYahuLg42e127+vll18usa2sxfdMJpOmTJmilStXKjIyUv3791dOTo4efPBBderUSZ9//rkiIyP1xBNP6Oeff1bfvn3PGFNZis47W9T777+vlStXqmnTppo0aZKmTp2qjIwM7/4TJ07oL3/5i9q0aaPp06frj3/8Y4UWPC/Lp59+KrvdrptuukmS1KJFC+3atUvbtm1TixYt9Pnnn2vChAmlHjto0CDvHLwAAACAr1X1vqWgoECLFi3SRRddpNDQUO8X+0FBQfrss880ffp0TZgwQdnZ2Ro5cqRmzZql7OxsNWnSxPtw1JNPPqnXX39dZrNZl1xyiVq0aKGQkBA98sgjMplM3mmgyrJ7926FhoZ6p7r67rvvlJCQoCuuuEJjxozRJZdcooMHD2rUqFG65JJLdMkll2js2LEaN26cGjduLOn3pEvbtm1lMpl0ySWXSPo92VFacqJQWQ9DBQcHa/r06TIMw/u69dZby53iaePGjbrqqqt0/vnna8yYMUpNTdX+/ftLvAYPHqwZM2Zo9erV6tatm2bNmlWsHpfLpeuuu05RUVHeBFXhg25McQugLiGpAQB+MG3aNL377rvavn27IiMjvQvOpaSk6KGHHvK+DwgIUFhYWLEvsh977DEdPXpU//d//1eszq1bt+pvf/ubcnJyvNvWr1+v1NRU9e7du1jZIUOG6IknntCjjz6q+Ph470Jw999/v/72t7/pn//8Z4WSGqU9nVRZhw4d0g033KDRo0frxx9/1KFDhzRu3Dh98sknuvDCC/XWW29p1apVuvDCC/Xzzz+fVTtFn1CSPOt0FC6MV7gw3zPPPKM+ffooLS1NkvTMM88oPT1dJ0+e1KFDh/TNN99oyJAhJRJFFfXaa6/p9ttv9940DB48WNnZ2briiit0xx13aOnSpRo+fHipx8bExOjQoUNVahcAAACorKret8yaNUsFBQXq1auXJM+6DEePHpXNZlNQUJByc3MVFRWlsLAwpaenq0WLFgoLC5P0e8Lgxhtv1Isvvqg333xTDz30kI4cOaLPPvtM2dnZ+vnnn/Xiiy+WuSi3JMXFxWnXrl3avn27JJVIGmzfvl179+7V4MGDNXPmzFLvbQpjWbVqlfbt26cPP/xQkidhsXDhQnXp0kXJycmV6lOTyaSCggKdPHnS+3I6nWUmQfLy8nTllVeqQ4cOuu6669S5c2fFxcWpTZs2pb5mzpypX3/9VZ06dVL37t299RiGobvuukvfffedNm/erODgYJlMJnXu3FmSZzRH0cXQJ02aVKnzAoCaRFIDAPxg8uTJevnll7Vs2TLt3LlT+/bt08GDBxUfH6+nnnrK+wX73r17tXPnTnXt2tV77JgxY/Tyyy+XGBp8/fXXKz8/X19//bV325o1a7yjMUpjt9v15JNPSpISExM1ZswY5eXlVfg8HA6HDMMo9oG8oKCgxLbc3NxSj502bZoSEhIUEhKiBQsWqG/fvtq9e7d69eqlKVOmKCMjQw8++KBiY2N1xRVXaNiwYZo+fXqF4yuqcHqnor755hsdOHBA999/vzZu3KilS5dq1apVOnDggF566SW5XC7NnDlT8fHx2rlzp3744Qft2bNH/fv310MPPVTmtFpl+fXXX7V27Vrdeeed3m3BwcFat26d9u3bp44dO2rgwIG677771KRJE33yySfFji+cqgoAAACoCVW9b1m1apVycnIUFRWltWvXauzYsRowYIC33pSUFM2ZM0eHDx/Wnj17tHHjxhJt9+rVSw8//LAmTJjgXZg8Li5OYWFh6t+/v8aOHVtu7DabTe3bt/c+2HT65+hnn31W55xzjho1aqS77rpL99xzT4k6ChMdLVq0UOvWrRUdHe3dN3LkSHXr1k3//Oc/K9KVxTz88MNq1KiR91XWIt6S535h8eLF+uGHH3T99dcrLS1NaWlpslgseuedd5Sdne19XXTRRYqPj1fHjh2VmJjoHemen5+vG264QR988IHGjh2rHj16aN++fdq3b59WrFghSd57kn379mncuHGM3ABQq/HNCAD4QUxMjB544AENGzZMHTp0UOvWrRUTEyOLxaJGjRqpRYsWatGihWJjY9WhQ4diHyhHjhypyZMnl6izefPmGjVqlD777DPvtl9++cU7RLo0zzzzjBwOh7p166b77rtP6enpGj9+fLnDuIvKzc1VampqsQ/kDz/8cIltPXv2LHGs2+3WnDlz9Morr+jdd9+VzWZThw4dNG7cOP3rX/9SZmampk2bpt69e2vFihV64YUX9MEHH+iiiy6qUGyni4mJ0cGDB4tt27FjhyQVG/XSr18/9enTR+vXr9fRo0eVkZGh22+/3TvdV2BgoG666SYdOHBAR48erVQMs2fP1qBBg7xz9BYKCAhQy5Yt9fHHH2vo0KH69NNPNW3aNE2dOrVYuUOHDikmJqZSbQIAAABVVdX7lueff16pqanKzc3Vueeeq0WLFhUb0bB582bFxcVp8uTJys7O1ksvvVTi4apff/1V119/vW699VY99dRTkqSpU6fqtttu00033aR169ZV+by+//57ffjhh3rsscfUs2dPzZw5U2+++aaefvrpYuVOfyiqkGEYMpvNuvfee/Xf//7Xe19RUaVNP1Wedu3aKSoqSsHBwWrSpIkOHTokl8ulvn37KiwszPs6cuSIYmNjix3rdDo1cuRIzZ07V3PnztXIkSNls9nUunVrtW7d2vuwXExMjHdbSEhIuaNgAMDfSGoAQA0qHMFQUFBQ4WMKF7grbbTD6caMGaNFixbJ4XDo+PHj2rp1q0aPHl1q2eXLl+uf//ynXnzxRQUHByssLEyff/659uzZo8OHD3tjLG+KqcOHD6tv377FPpBPnz5dcXFxxbaVNtesYRhauHChrr32WknS5Zdfrvnz5+uZZ55R48aN1b17d40ePVo///yz7rrrLknSxIkT1aZNmwonXYrq27evli9fXmxb4fy+p09LFRQUpMDAQIWGhkpSiUW7C4euV+bpJbfbrc8++0zjx48vdf/BgwcVFRWlo0ePqnPnzpo4caJSUlKKlVm2bJn69etX4TYBAACAqjjb+5bo6Gi1adNGwcHB3n2FC4Tn5uZq9erVmjVrluLj4zV8+HB16dJFb7/9drH6QkJC1KVLF3Xv3l3t27eXJHXs2FHdunVTXFycgoKCvPcqlZkWNzExURMnTtSECRM0ceJESdINN9ygKVOm6G9/+1uxdSgK6z18+LD279/vnaK2cPs111yjV199VXFxcRVuv7xESUV99dVXatKkiXr06FFs+/79+0s8QGW1WvWvf/1LP/744xlHtwBAXUFSAwBq0JEjR9SoUSMFBgYWm6+08PXbb7/pwQcfLLbNYrEoODi41EWuTzdq1ChlZ2dr5cqVWr58uQIDAzV06NAS5davX6/x48dr3Lhx+sMf/uDd3r59e23atElt2rRRfn6+JM8UVWXZunVrsXlaK+POO+9UWFiYgoKCSrx2796tRx55pNR9oaGhmjlzZqXbGzdunL7//ntlZmZ6t/Xv31/5+fneeXYlKTMzUxs3btS5556r8PBwderUqcRw+OXLl6tTp07eBQQr4pdfftHBgwd12WWXlbr/7bff1m233Sap7Buajz76SFdffXWF2wQAAACq4mzvWzZt2qSpU6fq2muv1datW3XDDTfo3//+tyTps88+U1xcnBISErRixQpNmDBBN998s7Zt21Yshu7du+uJJ57QQw89pOuvv16SNGnSJD300EN66qmn1K1bN++9Snn3LIWfrU+ePOldv65v3756//33i5V76qmndPHFF+vOO+/0rmNXmIA477zz1KZNG91www2SPKMfJCkyMlJ33313pR52ysvL03333Ves72bOnFnuORR19OhRTZs2TTfffHOxKbXy8/N1/PjxEkkNSRo0aJDOP//8Yv1RnupYOxEAfMnq7wAAoCFp2rSpdu7cqcDAQAUFBZVYDK5///667bbbdMcdd3i3uVwu2e32MheOkzwf4gMDA9W5c2f99NNPGjRokO68804NGjTIO6rA7XbL5XLJZrPp3//+tyIjI/XOO++UqKtwmHGbNm28H3gzMjJKlHM6nVq+fLlefPHFSveDJM2YMUMzZ86UxWIpsa9Dhw6699579cADD5TYZxhGlT5kN2vWTBMnTtSUKVP02muvSfLcnJx//vmaMGGC/vGPfyggIEDPPfeczGazdwj4X/7yF91zzz2Kjo5Wv379tHDhQn3wwQfeJ8kKCgq0adMmdejQodwkx6JFi9SiRQvvU2ZF2e12nThxQq1atZJhGNq+fbtmz56t+Ph4b5nCRRF5ugoAAAC+drb3LRkZGdq9e7cuueQSbdy4Ua+//rqGDx+uXr166aKLLtKkSZO0Y8cOHT9+XBMmTFBUVJRuvPFGzZkzp9R4Cu9LNm3apI0bN2r79u1KS0vT66+/Xu6X9Hl5eZo0aZJsNptuueUWzZo1S1OnTtVDDz1UIhFhNpv1wQcfaP369d4pXwuTGnv27FF8fLyWL1+um266qczRFqUpLGsYhkwmkzZt2lTq/YzVai12rqXd/x08eFBjxoxRSEiIHn/88WL7du7cKcMwSk1qFFX48Fppli1bpgULFmjhwoXF1gEEgNqGpAYA1CCLxaIOHTqUWyYkJKTYAnRlcblcMgxDdrvdO6y7NEU/DE+ZMkX/+Mc/NHPmTO3bt6/CIw1Ku1H48ssvdfLkSV1++eUl4ir6Id3pdOrAgQOSPGtHFCr6e2UUPgVWFc8884x69OihCy64wDsN1Pz58zVlyhTdc889OnHihHr27KkffvhBzZo1kyTdcsststlseumll/TEE08oOjpa//rXv3TLLbdI8txY9O/fX/PmzdOVV15ZZttLliwpc7TNggULdN1110mSWrdurWuvvVYPPfSQ/vOf/0jy3KDcf//9+vzzz6t87gAAAEBFne19S2xsrD788ENJ0ssvv+y9n3C73WrRooX3QZ2UlBQFBgZqy5YtyszMVHZ2tnf0weTJk5WUlKSjR49618a75ZZb1KFDB3Xq1KnEiPT09HRlZGR4kwPHjh3T5ZdfroKCAh07dkxLly7VpEmT1K1bN1mtVnXt2lXNmjVTSEiIrFarnE6n8vLyZBiG5s2bp3Hjxik0NFR9+/b1JkCGDRtWYopYSd71QI4ePVpiQfLs7GxJnoehAgMDFRISUmqfuVwu/fDDD1q8eLEkFbvHczqd+vjjjzVlyhSZzWYtWLDAey+XmJio77//Xt99950iIiLUpUuXUusvZBhGsYRO4b2bYRgKCgrSq6++qsGDBxdLWAFAbUNSAwBqEZfLVeGnfhwOh9xutwICAvTrr78qJCSkxAfoopxOpyIiIiR51oIoepNyeiKiqMcee8y7qF/hqA+n06m///3vuvLKK0vcyOTn5xd7+mf8+PH6+uuv1bVr12IjD8pTXjxnIzIyUl999ZXGjh2rESNGKDIyUuHh4Zo+fbqmT59e5nE33HCDd6j56eLj4ys0hHvp0qVl7js9MXR6PJMnT9aTTz5ZoSnIAAAAAF+r7H1LYdnTFwMv/HL9rbfe0vTp0zVgwADvSINmzZqpTZs2GjdunHr06KFu3bopPj6+xD1PTk6OunbtqsOHD8vtdnunxw0JCVHfvn316KOPKiIiQldeeaWGDx+uTz75RMuXL9fs2bN14MABZWZmlliz78EHH9S4cePUp08frVmz5oznePfdd+v999+XzWYrkWw5PalRFovFoqeeekrr16/XtddeW2xdvy+++EKTJ0/WjTfeqBdeeKHYPVh8fLymT5+ufv366ZtvvjnjVFiPPvqoHn30Ue/7wv9tHA6HBg4cqOzs7HJnCQCA2sBkVGYlIgCATzVv3lx/+tOfNGXKlDOWff755zVt2jTvfK9no1u3brrsssv0/PPPl9h33XXXaefOnbr44os1depU71NMn3/+ubp161ZicbrCJ6Tatm0rybOWRHp6ui644IIKzzUbExOj++67T4899thZn1tpTpw4oaioKJ/U7Qt1LV4AAADUb5W5b+ncubNeeukljRkzpswyBw4cUG5urjp27FileKZNmyZJGj16tLp161bp44smaSwWS6VHR+/atUvJyck699xz1bx580q3X2jfvn1q1qxZqfdNqampio2NrXLdZdmwYYN69+6tbdu2qXPnztVePwD4AkkNAAAAAAAAAABQJ5Q9TwkAAAAAAAAAAEAtQlIDAAAAAAAAAADUCSQ1AAAAAAAAAABAnUBSAwAAAAAAAAAA1AlWfwcAAAAAAKgct9utgwcPqlGjRjKZTP4OBwAAAKgQwzCUnZ2tli1bymyu2pgLkhoAAAAAUMccPHhQbdq08XcYAAAAQJXs27dPrVu3rtKxJDUAAAAAoI5p1KiRJGnPnj2KioryczS+43A4tGDBAo0ePVo2m83f4fhEQzhHqWGcZ0M4R6lhnGdDOEepYZxnQzhHqWGcZ0M4R6lhnOeJEyfUtm1b7+fZqiCpAQAAAAB1TOGUU40aNVJ4eLifo/Edh8OhkJAQhYeH19sb+4ZwjlLDOM+GcI5SwzjPhnCOUsM4z4ZwjlLDOM+GcI5SwzhPh8MhSWc1hSoLhQMAAAAAAAAAgDqBpAYAAAAAAAAAAKgTSGoAAAAAAAAAAIA6gaQGAAAAAAAAAACoE0hqAAAAAAAAAACAOoGkBgAAAAAAAAAAqBNIagAAAAAAAAAAgDqBpAYAAAAAAAAAAKgTSGoAAAAAAAAAAIA6gaQGAAAAAAAAAACoE0hqAAAAAAAAAACAOsHq7wAAADgb6+zrlOnOlFlmmYr+n8kks8wKMAUo0BTofQWZgrw/A0wBMplM/j4FAAAAAAAAVBBJDQBAnbbbsVsHnAeqdKxJJm/SozDZUfT3RuZGirBEKMIcoUbmRrKa+M8mAAAAAACAP/HtDACgwTJkKN/IV76RryxlnbF8mClM4ZZwRZg9iY5wc7g36RFqDq2BiAEAAAAAABo2khoAAFTQSeOkTjpP6qAOlthnlVXh5nCFW8IVaY5UU0tTNbM2U5Q5iimuAAAAAAAAqglJDQAAqoFTTp1wn9AJ9wmlKMW73Saboi3Ram5trmaWZmpmbaZIc6TMJrP/ggUAAAAAAKijSGoAAOBDDjl0yHVIh1yHvNussnpHchQmOqLMUSQ6AAAAAAAAzoCkBgCg1lu1bpV+XvuzTCaTzCazTGbPT7PZLNcgl9TE3xFWjlPOUhMd0ZZotbS2VKwtVq2srViYHADqmOPHj6tfv35aunSp4uPjz1h++fLluvPOO3Xs2DE99thjeuihh3wfJAAAAFDH8W0JAKDW23Ngj/bs36OoiCgZhiFDhjz/byiyIFIBCvB3iGfNKacOuw7rsOuw1uWvk0UWxVhjFGuNVRtbGzW3NGdtDgCoxdLS0nTZZZcpJSWlQuWPHTumyy+/XA8//LCuvfZaTZw4Ub1799YFF1zg20ABAACAOo6kBgCgTggOClaLpi1KbHcGOP0Qje+55NJ+537td+6X7FKQKUitra0Va4tVrDVWEZYIf4cIAChi4sSJmjhxohITEytUfvbs2YqJidETTzwhk8mkv/3tb5o5c2aZSY38/Hzl5+d732dlZUmSHA6HHA7H2Z9ALVV4bpxj3dcQztNf57h//34dP35cTZo0UevWrSt9nKRKHVt4fuvXr1fTpk0r1WZlVfXczlZD+PcqNYzzbAjnKDWM82wI5yg1jPOsjnMzGYZhVEMsAAD4zMfzP9a6pHVq27ptiX3O85x1bvqp6hBuDlesNVaxtli1sbZRkDnI3yEBQIO2e/dutWvXTiaTSXv27Dnj9FOTJ09WcHCwXn/9dUnSoUOHNHLkSCUnJ5da/u9//7uefPLJEts//vhjhYSEnHX8AAAAQE3Izc3Vddddp8zMTIWHh1epDkZqAABQB2W5s5RUkKSkgiSZZFJzS3N1DOiojgEd1cjcyN/hAUCD065du0qVz8rKUrdu3bzvw8PDdeDAgTLLP/roo8XW3MjKylKbNm10wQUXqEmT+pvddzgcWrhwoUaNGiWbzebvcHyiIZyj1DDO0x/nuHHjRp1//vm64OpbtfSzmfrpp5/Us2fPCh93zYP/kCTNefnxCh+7fv16HTp0SO99vVQLPplR4eMqq6rnVh0awr9XqWGcZ0M4R6lhnGdDOEepYZxn4SjBs0FSAwBQfZxOKT1dysuTXK7iL7fb87NZMykmxt+R1iuGDM96HHmHtSJvhWIsMeoU0EkdAzoq1Bzq7/AAAKWwWq0KDAz0vg8KClJubm6Z5QMDA4uVL2Sz2ertDW9RDeE8G8I5Sg3jPGvyHM1ms/Ly8hTWpIXy8vJkNpsr1HbhcU1aeUZCV/ZYSQqNal6p4yqrqudWnRrCv1epYZxnQzhHqWGcZ0M4R6l+n2d1nBdJDQBASVlZ0oEDngRFRobnZ2mv0/edPHnmup94QnrqKV+fQYN2yHVIh/IO6ae8n9TS2lIdbZ4RHCFmpicBgNoiKipKx44d877Pzs5WQECAHyMCAAAA6gaSGgDQEDmdUmqqtHu3tGeP52fha88eqRqGAsL/DBk64DygA84DWp63XK2trdUpoJPa29or2Bzs7/AAoEHr37+/PvnkE+/7DRs2qFWrVn6MCAAAAKgbSGoAQH2Vlydt2SL99lvxhMXu3dK+fZ7EBhoMQ4b2Ofdpn3Oflmqp2ljbqGNAR3WwdVCgueR0JgCA6pGVlaXg4OASw+wvv/xy3XPPPVq6dKmGDh2qF198URdddJGfogQAAADqDpIaAFAf5OVJGzZIa9f+/kpO9qxhAZzGLbf2Ovdqr3OvlmqpOgV0Uo/AHmphbeHv0ACg3unRo4emTZumK6+8stj26Oho/fvf/9ZFF12kiIgIhYaGaubMmf4JEgAAAKhDSGoAQF2Tm1sygbF1KwkMVIlLLm0t2KqtBVvVzNJMPQJ7qHNAZ1lNfEQAgKowDKPY+5SUlDLL3n333Ro9erS2bt2qYcOGKTw83MfRAQAAAHUf31gAQG3mcklr1ki//PJ7AmPbNhIY8ImjrqNalLtIK/JWqFtAN50TeI4iLZH+DgsA6rUOHTqoQ4cO/g4DAAAAqDNIagBAbbNjh7RokbRwobRsmZSR4e+I0MDkG/lan79e6/PXK9Yaqx6BPdTW1lZmk9nfoQEAAAAAgAaOpAYA+FtamieJUZjISE31d0SAV6ozVanOVIWZwnRO4DnqHthdoeZQf4cFAAAAAAAaKJIaAFDT8vKkFSt+T2Js3CidNv82UNucNE5qlX2VfrH/og62DuoV1Esx1hh/hwUAAAAA/8/enYdHVR7sH7/PnJnsgSQQwr7v+yI7oijiiiuIAipqUdHWpdZa37ZvtVprF6116evPunVRW7e2WkVFlEUQlFXDIllI2BII2SbLZDLb749gKiUJGZLMycx8P9eVq+bknGfu57oCJbnneR4AUYZSAwBCISdHevNN6cMPpXXrpJoaqxMBp8Qvv/Z49miPZ4962Xtpcvxk9bD3sDoWAAAAAACIEpQaANBW8vKk116T/v53acsWq9MArW6/d7/2V+xXT3tPTY6brJ6OnlZHAgAAAAAAEY5SAwBa04ED0uuv1xUZGzdanQYIiQPeAzpQeUA97D00KW6Sejt6Wx0JAAAAAABEKEoNAGipwsL/FBnr13M+BqLWQe9B/aPyH+pmdtPk+Mnq4+hjdSQAAAAAABBhKDUA4FQUFdWdkfH3v0tr1kh+v9WJgHajwFegf1b+U13NrpoUP0n9HP2sjgQAAAAAACIEpQYANJfXK/3jH9Jzz0krV0o+n9WJgHat0FeotyvfVheziybFTdKAmAFWRwIAAAAAAGGOUgMATubgQenZZ6U//lEqKLA6DRB2jviO6N9V/1Z6TbpmxM/gzA0AAAAAAHDKKDUAoDErV0p/+IP09tt1qzQAtEiRr0j/qPyH+jn66fT405VqplodCQAAAAAAhBlKDQD4tvJy6aWXpGeekXbvtjoNEJH2evYq35OvUbGjNDlusuJt8VZHAgAAAAAAYYJSAwAkaevWulUZr7wiVVdbnQaIeH75td29Xbtrd2tS3CSNiR0j0zCtjgUAAAAAANo5Sg0A0cvtll57ra7M2LDB6jRAVHIH3FrrWquv3F/pjIQz1NfR1+pIAAAAAACgHaPUABB9qqrqioxHH5UOH7Y6DQBJZf4y/avyX+rn6Kcz4s9QR7Oj1ZEAAAAAAEA7RKkBIHpUVEhPPSU99ph09KjVaQA0YK9nr/Z59mlC3ARNjJsou8E/VQAAAAAAwH/wmwIAka+8XHriCenxx6WSEqvTADgJn3z6vOZz7ardpZnxMzUwZqDVkQAAAAAAQDtBqQEgcpWV1RUZv/993X8DCCsV/gq9W/WuBtYO1KyEWUqwJVgdCQAAAAAAWIxSA0DkKSmp22LqySclp9PqNABaKNuTrYPOg5qVMEuDYgZZHQcAAAAAAFiIUgNA5Dh6VPrtb+sOAa+osDoNgFbkCrj0XtV7GlQ7SLMSZineFm91JAAAAAAAYAFKDQDhr7hYeuQR6f/+T6qqsjoNgDaU5cnSAecBVm0AAAAAABClbFYHAIBTVlsrPfqoNHBg3QoNCg0gKnyzamN55XK5/C6r4wAAAAAAgBBipQaA8PTmm9K990o5OVYnAWCRPZ492u/cr7MSztLAmIFWxwEAAAAAACHASg0A4WXTJmnmTGnePAoNAHIFXHq36l0tr1yuGn+N1XEAAAAAAEAbo9QAEB4KC6UlS6RJk6S1a61OA6Cd2ePZo784/6KcWspOAAAAAAAiGaUGgPbN65Uee0waMkT605+kQMDqRADaqepAtf5d9W+trFopb8BrdRwAAAAAANAGOFMDQPu1cqV0++3Szp1WJwEQRjJrM3XEd0QXJF6gjmZHq+MAAAAAAIBWxEoNAO3Pvn11Z2bMnk2hAeCUHPEd0asVryq3NtfqKAAAAAAAoBVRagBoP/x+6fHHpWHDpDfftDoNgDDnDrj1TtU7+rT6U/kDfqvjAAAAAACAVsD2UwDah+xs6frrpU8/tToJgAiz2b1Zh32HdV7ieUq0JVodBwAAAAAAtAArNQBYKxCQfv97acwYCg0AbeaA94Bedb6qg56DVkcBAAAAAAAtQKkBwDo5OdIZZ0h33ilVV1udBkCEqwpU6c3KN7WpZpPVUQAAAAAAwCmi1AAQeoGA9MQTCoweLa1da3UaAFEkoIDWudbpncp35A64rY4DAAAAAACCRKkBILRyc6VZs6Q77pDB6gwAFsn15OpV56s64j1idRQAAAAAABAESg0AoREISE89Vbc6Y/Vqq9MAgMr95Xqt4jVl1WZZHQUAAAAAADQTpQaAtrd3r3TWWdL3viejqsrqNABQzyef3qt6T1tqtlgdBQAAAAAANAOlBoC29dxzCowaJa1aZXUSAGjUWtdara5erUAgYHUUAAAAAADQBEoNAG2julq67jpp6VJWZwAIC9vc2/Ru1bvyBrxWRwEAAAAAAI2g1ADQ+vbsUWDyZOnPf7Y6CQAEJceTo7cq3pLL77I6CgAAAAAAaAClBoDW9cYbCkyYICMz0+okAHBKCnwF+nvF31XmK7M6CgAAAAAA+C+UGgBah8cj/x13SPPny6istDoNALRIub9cr1W8pgJvgdVRAAAAAADAt1BqAGi5gwflnT5dtieesDoJALQaV8CltyreUk5tjtVRAAAAAADAMZQaAFoksGKFvKNGyf7FF1ZHAYBW55VX71a9q20126yOAgAAAAAARKkB4FQFAvL97GfSuefKXlpqdRoAaDMBBbTatVprqtcoEAhYHQcAAAAAgKhmtzoAgDBUUiLPlVfKsXKl1UkAIGS2urfKHXBrdsJsGYZhdRwAAAAAAKISpQaA4GzdKs+FF8pRwOG5AKLPztqdkkSxAQAAAACARdh+CkCz+d59V77p0yk0AES1nbU79VH1R2xFBQAAAACABSg1ADRLze9/L+Pii2W6XFZHAQDLUWwAAAAAAGANtp8CcFLOZcvU4ZlnrI4BAO0KW1EBAAAAABB6lBoAGuV3u1V20UVK++gjq6MAQLtEsQEAAAAAQGhRagBokOvQIVXPnq1Ou3ZZHQUA2jWKDQAAAAAAQoczNQCcoHTTJrnHj6fQAIBm4owNAAAAAABCg1IDwHEOv/22YmbNUsrhw1ZHAYCwQrEBAAAAAEDbo9QAUO/g008rZf58JVZWWh0FAMISxQYAAAAAAG2LUgOAAoGA9v3wh+p6++2Kra21Og4AhLWdtTv1cfXHVscAAAAAACAicVA4EOV8Pp/2X3ed+r78stVRACBiZNZmKsmWpMnxk62OAgAAAABARGGlBhDFamtqlHvllRQaANAGNtRs0E73TqtjAAAAAAAQUSg1gChVVV6urCuu0KC33rI6CgBErJXVK5Xvybc6BgAAAAAAEYNSA4hCpYWFyr7iCo147z2rowBARPPLr/cq31ORt8jqKAAAAAAARARKDSDKHMrOVs6VV2rMypVWRwGAqFCrWr1d+bYq/BVWRwEAAAAAIOxRagBRJGfrVu1fvFinrV1rdRQAiCqVgUr9q/JfcgfcVkcBAAAAACCsUWoAUWLnunU6vHSpJm/caHUUAIhKxb5ivVv5rnwBn9VRAAAAAAAIW5QaQBTYuW6dSm+/XdM2b7Y6CgBEtf3e/VpZzfZ/AAAAAACcKkoNIMJ9U2hM37LF6igAAEm7anfpM9dnVscAAAAAACAsUWoAEYxCAwDap89rPlemO9PqGAAAAAAAhB1KDSBCUWgAQPv2SfUnyvfkWx0DAAAAAICwQqkBRKCd69bp0A9/SKEBAO2YX369X/W+nD6n1VEAAAAAAAgblBpAhNm5bp2y7r9fZ33Gfu0A0N7VBGr0btW78gV8VkcBAAAAACAsUGoAEWTnunXa/sgjOn/VKtkCAavjAACa4YjviFa7VlsdAwAAAACAsECpAUSInevWacPvfqeLV65UjNdrdRwAQBC+cn+l3e7dVscAAAAAAKDdo9QAIsDOdeu05umndclHHynR5bI6DgDgFHxc/bGKfcVWxwAAAAAAoF2j1ADC3K716/Xx//t/uujjj9WpvNzqOACAU+SRR+9WvqvaQK3VUQAAAAAAaLcoNYAwtnf7dq14/nnNXrtWPQ8ftjoOAKCFSv2lWlm10uoYAAAAAAC0W5QaQJgqzM3Vh889p8nr12toXp7VcQAArWSPZ4+212y3OgYAAAAAAO0SpQYQhkoPH9b7/+//qe+nn2rybg6WBYBIs9a1VoXeQqtjAAAAAADQ7lBqAGGm2unUB88+q4Q1a3TOdt7JCwCRyCef3qt6Ty6/y+ooAAAAAAC0K5QaQBjxuN366IUX5Fq5Updt3ixbIGB1JABAG6nwV+iDqg8U4O96AAAAAADqUWoAYcLn82nVyy9r74cfasGmTXJ4PFZHAgC0sXxvvr6o+cLqGAAAAAAAtBuUGkAYCAQC+vztt7Xlvfc0/8svlVBVZXUkAECIbKzZqCJvkdUxGrR48WL98Y9/bPKexx9/XH/9618lSW63Wx6Ph9UnAAAAAIBTRqkBhIGvVq3Sujfe0Dk5Oep+8KDVcQAAIeSXXyuqV8gX8Fkd5QQDBgzQ8uXLm7ynS5cu+u53v6v9+/fr3nvvVUxMjGw2mwzDOO7jpZdeCk1oAAAAAEBYo9QA2rmcLVv0yV/+osGHD2vctm1WxwEAWKDIV2T5NlQLFiyQ3W4/7uMXv/iF3n777ROuf/e7361/7qqrrtLMmTPlcDj08MMPq6KiQlVVVXK5XPUfp59+uhwOh4WzAwAAAACEC0oNoB07lJ2tFc8/r4SjR3XuunUyrA4EALDMFzVf9r2QvwAAnUlJREFUWLoNlWma+slPfiKv16uvvvpKNTU18nq98nq9crlc9f+9ePFimaYpSbrpppu0cuVKvf322+ratasSEhL0u9/9TqtXr1ZcXFz9h81mq38GAAAAAICmUGoA7VRpYaE+ePZZVRQU6IovvlBsTY3VkQAAFvLLrw+rP7RsG6pp06Zp7Nix2rx5s6ZNm6b77ruv/mvnnnuu5s2bp6+//lrz58/X+eefL0n68ssvVVR0fBHzxRdfKD8/P6TZAQAAAACRg1IDaIfc1dVa8fzzKszO1qV79yqtsNDqSACAduCo76g+r/ncktf+7ne/q5qaGp155plauHChHnnkkfqvPf/883I6nRo5cqRWrlyp008/XZLqV2HccMMNGjRokIYOHapPPvlEDzzwgIYOHaoBAwbUHyIOhLvMzExNnDhRqampuueeexQIBE76zG9+8xtlZGSoQ4cOuuKKK1RcXByCpAAAAEB4o9QA2plAIKBPX39d2Zs3a4bbrUGcowEA+JZNNZt0xHsk5K971VVXadGiRXrggQf09NNPH7ddVL9+/fThhx/q97//vf7whz/ozjvvPO7ZBx54QP/+97919913q7KyUnfeeafef/99LV++XBdeeGGIZwK0Prfbrblz52rChAnatGmTdu7cqZdeeqnJZ9asWaM//elPWrNmjbZs2aKamhrdfffdoQkMAAAAhDG71QEAHG/HmjXa8v77GhQXp6nvvGN1HABAO+OXXyuqV+iq5KtkGqE7h2Lu3LmaN2+ezjvvPPl8vhPOwPB6vbr66qs1evRo9ejR47iv9erVS36/X9dcc40SExMVCAR000036eWXX1ZqamrI5gC0leXLl6u8vFyPPfaYEhIS9PDDD+u2227T9ddf3+gzn3/+uS644AINGTJEknT11VfrD3/4Q6P3u91uud3u+s+dTqckyePxyOPxtNJM2p9v5sYcw180zNOKOfr9fsXHx8tu2hQfHy+/39+s1//mOfPYwY3BPisp6NcM1qnOrTVEw/erFB3zjIY5StExz2iYoxQd82yNuRmB5qyLBhAShbm5evPXv5acTl3zwQfqUFJidSSg9f30p9LPfx7UI6+884q2ZG5Rv579Tviad6pX6tRa4YDwMSlukqbGTw3pa95zzz16+umnFRsbK9M0VVlZKcMwlJiYWH9g+Msvv6x58+ZJks4880zdcsstuuqqq/Twww9r1apVSkhI0EUXXaQvvvhCmzZt0tq1a3XBBRfU3weEowceeEAbN27Ue++9J6lu5W2nTp1U0sS/5d5//31997vf1QcffKDk5GQtWLBAM2fO1AMPPNDg/ffff3+DX3vllVeUkJDQOhMBAAAA2lh1dbUWLlyo8vJydejQ4ZTGYKUG0E5UO5366MUXVXH0qBbu3EmhAQBo0qaaTerv6K8Me0bIXvPXv/61fvOb39R/vmTJEqWkpOjxxx+vv9bQ+2VeffVV/e53v9PmzZt1++23S5KeeuopTZkyRb/+9a/bPDfQ1pxOp/r1+0/xbhiGTNNUaWlpo6uRzjvvPA0aNEgDBw6UJE2cOFE/+tGPGn2N++67T9///vePe81evXpp1qxZ6tQpctt9j8ejFStW6JxzzpHD4bA6TpuIhjlK0TFPK+a4fft2zZw5U5fd9lP94+kHtWbNGo0ZM6bZz3330ZclSU/dvajZz27dulUFBQV667Pdev2JB5r9XLBOdW6tIRq+X6XomGc0zFGKjnlGwxyl6Jhna5wjR6kBtAM+n0+rX3lF+ZmZmlNZqd67dlkdCQDQzvnl14qqFbq6w9Uh24bKMIyg76msrNSvfvUrvfHGG+rdu7dqa2vl8/nkcDj01ltvKSMjQ6tWrWqjxEBo2O12xcbGHnctLi5O1dXVjZYar732mvLz87V7926lp6frBz/4gRYvXqw333yzwftjY2NPeA1JcjgcEfsD77dFwzyjYY5SdMwzlHO02WxyuVzy+vxyuVyy2WzNeu1vnvMdey9CsM9KCvo1g3Wqc2tN0fD9KkXHPKNhjlJ0zDMa5ihF9jxbY16UGkA7sG3FCn358ccampys8ZyjAQBopmJ/sTbWbNS0+Glt+jqBQKBZhcZ/P+NyuZSUlKQdO3YoJiZG0n9+ESJJ6enpKikpUXFxcf3XgXCUlpamzMzM465VVFQ0+X396quvatmyZfVnajz++OPq2LGjysrKlJKS0pZxAQAAgLBGqQFYbN+OHVr3+utKTErSrPffl+nzWR0JABBGNtds1tCYoUoz09rsNdatW6ezzz5bCQkJxx0Q/s2ZGn/961/rr/n9de+mfPLJJ1VRUSFJx/1i99///nf9fx88eFCDBw9WSkqKxo8f32b5gbY2ceJEPffcc/Wf5+Xlye12Ky2t8T+XXq9Xhw8frv+8oKBAUt0KXgAAAACNo9QALOQ8elQf/+lPqqms1LlHjijt2A+zAAA0l19+rapepcuTL2+z15g8ebKOHj2q+Ph42e1N//PR5/OppqZGNptN3/nOd5q8d9CgQdq0aZNGjhzZ4LY6QLiYOXOmysvL9ec//1nXXnutHnnkEc2ePVumacrpdCo+Pv6EZfbTp0/XY489pp49eyo+Pl6PP/64pk6dGtHnYwAAAACtgVIDsIintlYf/+UvOpiVpdGdO2vkG29YHQkAEKb2e/crqzZLg2IGtcn4weznapqmEhMTmz32hAkTTjUW0G7Y7XY9++yzWrhwoe65556689JWr5YkjR49Wo8//rguvfTS45658847dejQIT344IM6evSopk6dqueff96C9AAAAEB4odQALBAIBPTFO+9o16efqnv//pr+yisy/X6rYwEAwtha11r1c/ST3eCfd4AVLr30UmVlZWnTpk2aNm2a0tPTJdVtRdWQuLg4PfHEE3riiSdCmBIAAAAIf/zUC1ggZ8sWbfzXv9SxSxdN2LJFaYWFVkcCAIS5Cn+Fvqj5QlPjp1odBYhaPXr0UI8ePayOAQAAAEQ0m9UBgGhTUVKi1a+8Ip/Xq76BgEasWWN1JABAhNhcs1nlvnKrYwAAAAAA0GYoNYAQCgQCWv/GGyrMzVXXvn015V//YtspAECr8cmnta61VscAAAAAAKDNUGoAIfT1xo368pNPlN6nj0avX8+2UwCAVpfjydEBzwGrYwAAAAAA0CYoNYAQcRYXa93rr8uw2dSzpkYj1vJOWgBA21jjWqNAIGB1DAAAAAAAWh2lBhACfr9f6994Q4dzc9W1Tx9N/ec/2XYKANBminxF2lW7y+oYAAAAAAC0OkoNIAT2bNyor1atUnqfPhqzfr1SDx+2OhIAIMKtd62XJ+CxOgYAAAAAAK2KUgNoY87iYn16bNup7rW1Gs62UwCAEKgKVGlzzWarYwAAAAAA0KooNYA25Pf7te7113Vk715l9O+v05YvZ9spAEDIbK7ZrEp/pdUxAAAAAABoNZQaQBvas3GjMtesUXqfPuq3a5cy8vKsjgQAiCJeefVFzRdWxwAAAAAAoNVQagBtxHn0qD597TXZbDZ1SEjQuBUrrI4EAIhCO9w7WK0BAAAAAIgYlBpAG/D7/Vr3xhs6kpenjH79NHLNGiU6nVbHAgBEIZ982lSzyeoYAAAAAAC0CkoNoA18vWGDMlevVnrfvupYVqahGzZYHQkAEMUy3Zmq8ldZHQMAAAAAgBaj1ABaWWVpqda9/rpspqnEjh01/oMPZPp8VscCAEQxn3zaXLPZ6hgAAAAAALQYpQbQyja9+64O5+WpS79+6padrR5ZWVZHAgBAX7m/YrUGAAAAACDsUWoArehQVpa2r1yptG7dZDcMjfvwQ6sjAQAgSfLKqy01W6yOAQAAAABAi1BqAK3E5/Xqs7feUrXTqQ7p6RqwZYtSioqsjgUAQL2v3F/J5XdZHQMAAAAAgFNGqQG0kq83bFD2li3K6N9fjtpajVq1yupIAAAcxyOPtrhZrQEAAAAACF+UGkArqHY69dk//ym7w6G4xESNWLtW8VXsWw4AaH+212xntQYAAAAAIGxRagCtYMv77+twbq669O2rxLIyDd2wwepIAAA0yCOPtrq3Wh0DAAAAAIBTQqkBtFDR/v3aumKFOqany7TbNfqTT2T6fFbHAgCgUdtrtsvtd1sdAwAAAACAoFFqAC0QCAT0+TvvqKK4WClduyq5uFh9vvrK6lgAADSpVrWs1gAAAAAAhCVKDaAF8jMztXv9enXu3VuGYWjE2rWyBQJWxwIA4KS2ubfJE/BYHQMAAAAAgKBQagCnyOvx6PO335antlZJKSlKKilRX1ZpAADChDvg1te1X1sdAwAAAACAoFBqAKfo6w0btHf7dmX07StJdas0/H5rQwEAEIQv3V9aHQEAAAAAgKBQagCnwFVZqc/feUf2mBjFJiQosaxMfb/kF0MAgPBS5CtSgbfA6hgAAAAAADQbpQZwCjJXr1ZhTo7S+/SRVLdKw2SVBgAgDLFaAwAAAAAQTig1gCBVO53a+uGHiu/QQXaHQwnl5eq3fbvVsQAAOCVZtVly+V1WxwAAAAAAoFkoNYAg7Vq3Tkf371enHj0kScM//VSmz2dxKgAATo1PPu2o3WF1DAAAAAAAmoVSAwhCdUWFtn74oRI6dpRptyve6dSArVutjgUAQItkujMVCASsjgEAAAAAwElRagBB2LVunYr27fvPKo1161ilAQAIe+X+cuV586yOAQAAAADASVFqAM3kqqzU1g8/VFxysky7XXEVFRqwZYvVsQAAaBUcGA4AAAAACAeUGkAz7V6/XkX5+cet0rB7vRanAgCgdeR78uX0Oa2OAQAAAABAkyg1gGaoqarSlg8+UFxSkuwOh2KrqjRw82arYwEA0GoCCrBaAwAAAADQ7lFqAM2w+7PPdCQvT5169pQkDdy8mVUaAICIs7N2p7wB/v8NAAAAANB+UWoAJ+GurtaWDz5QbGKi7A6HFAhoIGdpAAAikCvgUnZtttUxAAAAAABoFKUGcBK7N2zQ4dxcdT62SqPHnj1KLC+3OBUAAG1jR+0OqyMAAAAAANAoSg2gCW6XS1s/+EAxCQmyx8RIkgZ98YXFqQAAaDsHvQdV5a+yOgYAAAAAAA2i1ACasGfjRhXm5qpzr16SpKSSEnXLybE4FQAAbSegAFtQAQAAAADaLUoNoBEet1tbPvhAjthYOb5ZpbFpkwyLcwEA0NayPFlWRwAAAAAAoEGUGkAjcrdtU2FOTv0qDZvXq/7btlkbCgCAEDjkPaRKf6XVMQAAAAAAOAGlBtCAQCCgnZ9+KsMw5IiNlST1ycxUrMtlcTIAANpeQAFl1bJaAwAAAADQ/lBqAA04kp+v/K++Ukq3bvXXBnNAOAAEraqkSns37lVlcWWzrp9MeUG59m7cq5qKmibvK84vDjorjkepAQAAAABoj+xWBwDaoz0bN6ra6VR6nz6SpLRDh9Tp0CGLUwFAeNny5ha9/oPXldY7TUeyj+jqJ67W+CvGN3r9ZD556hN9+OiHSumRotL9pfrOK9/RwOkD9fWqr/XnpX/WmbeeqXPuOkeFXxfqYOZBderTKQSzjFwFvgI5/U51sHWwOgoAAAAAAPVYqQH8l+qKCu1cu1bJnTrJMOqOBR/EKg0ACEp1ebXe/NGbuv3d23XP6nt05WNX6p0H3mn0+skcyT6ij5/6WD/67Ee699N7Neu7s7T8l8slSetfWq8Fv1ugz/70mSRp+9vbNWbumDadX7RgtQYAAAAAoL2h1AD+S+6WLSopLFRKRoYkyeFyqU9mpsWpACC8uCvcuuzhy9RteN02fj1G9lB1WXWj10/G7/VrweML1LFrxxOeqy6rVveR3etet8ot02HKHsNi1NZAqQEAAAAAaG/4iR/4Fp/Pp8zVq2WPiZFpr/vjMWDbNtm9XouTAUB4Se2ZqtPmnyZJ8nl8+vipjzV67uhGr59M16Fd1XVoV0mSu9KtNc+u0eiL6p6LTYpVZVGlAoGAtr61VeMuH9dGs4o+h32HVe4rV0ezo9VRAAAAAACQRKkBHOfQnj06+PXXSuvevf7agM2bLUwEAOHtYOZBPX3x0zJjTN238b6TXj+ZnSt26k83/klpvdI05+45kqRxl43Tkxc9qanXTlXJvhJ16s1ZGq1pj2ePJpoTrY4BAAAAAIAktp8CjrP7s89UW1Oj+KQkSVJqQYE6FhdbnAoAwlf3Ed116z9vVdehXfXqd1896fWTGTJriG5+7WbZ7Da9/bO3JUkTrpigh7Ie0oT5E9R9RHc9fenTevrSp1Xrqm31+UQjtqACAAAAALQnlBrAMc6jR/X1hg3q2KVL/bXeO3ZYmAgAwp9hGOo5uqcWPrVQme9l1p+D0dj1kzHtpvpP6a/LH7lcG1/ZWH89vkO8dq/cLXucXYlpiUpMS1T2p9ltMqdoU+QrUqmv1OoYAAAAAABIotQA6mVt2iTn0aPqkJ5ef60PpQYAnJI9a/boX//7r/rPbfa6f3LkrM9p8LphM5ocb/Mbm/XJU5/85znTJpv5n3/GVJVUKSE1Qa5yl7oM7KIuA7uoqqSqVeYCKceTY3UEAAAAAAAkUWoAkiRPba0yV61SXFKSbLa6PxadDh5UUlmZtcEAIExlDMrQ+pfWa/1L61V6oFT//vm/NWTWEPUe17vB6/Ed4iVJNc4a+Ty+E8brMqiL3v/1+/ry31+qeF+x3n/kfY29ZGz91ze9vkkT5k1QfMd4lR4oVemBUiWkJIRquhFvn2ef1REAAAAAAJBEqQFIkvZlZupwXt5xB4T3zsy0MBEAhLeO3TpqyYtLtPqZ1Xpk2iOqra7V4mcWN3r9G786/Vfa8eGJq+R6jeml+b+dr3/+5J/67Rm/VWqvVF360KX1X/d7/ErqnKSB0weqYFeBCnYVaOD0gaGYalQ45D0kb8BrdQwAAAAAAGS3OgDQHuxav15+n08xcXF1FwIB9d6509pQABDmhp09TMPOHtbs65L0s+0/a3S80648TaddeVqDX5v13VmSpLjkOP3gkx+cQlo0xSefDnkPqbejt9VRAAAAAABRjpUaiHrO4mLlbd9+3AHhnQ8cUKLTaWEqAADaF7agAgAAAAC0B5QaiHr7MjNVUVqq5LS0+mt92HoKAIDj7PfutzoCAAAAAACUGkD25s0yTVM206y7EAioF1tPAQBwnCO+I3L5XVbHAAAAAABEOUoNRLXyoiLt37lTHdLT6691yc9XQmWlhakAAGifWK0BAAAAALAapQaiWn5mpipLS5X0ra2neu/YYWEiAADaL87VAAAAAABYjVIDUSsQCCh70ybZHQ7ZbHV/FAy/X7127bI4GQAA7dM+L6UGAAAAAMBalBqIWmWHD+vA7t3Hbz2Vl6f4qioLUwEA0H5V+CtU5iuzOgYAAAAAIIpRaiBq7duxQ1VlZUpMTa2/1psDwgEAaBKrNQAAAAAAVqLUQFQKBALa8/nnssfE1G89JUndsrMtTAUAQPvHuRoAAAAAACtRaiAqlRQU6FBWljp26VJ/Lbm4WEnl5RamAgCg/TvgPaBAIGB1DAAAAABAlKLUQFTat2OHqsvLlZiSUn8tIzfXukAAAIQJd8CtI74jVscAAAAAAEQpSg1EnUAgoKzPP5c9NlaGYdRf70apAQBAsxR6C62OAAAAAACIUpQaiDrFBw/qUHb2cVtPGX6/MvLyrAsFAEAYYaUGAAAAAMAqlBqIOvVbT3XsWH8t7dAhxdTUWJgKAIDwQakBAAAAALAKpQaiTt6XX8rxX1tPdWXrKQAAmq3EVyJvwGt1DAAAAABAFKLUQFSpdjpVkJ2tpNTU465TagAA0Hx++XXUd9TqGAAAAACAKESpgahSmJuryrIyJX6r1DBra9X5wAELUwEAEH7YggoAAAAAYAVKDUSVguxs+b1e2R2O+msZ+fkyfT4LUwEAEH6OeCk1AAAAAAChR6mBqBEIBLR3+3bFJiYed52tpwAACB4rNQAAAAAAVqDUQNQoO3JExQcPcp4GAACtoNhXzGHhAAAAAICQo9RA1CjMyZHL6VRCx4711+IqK5VyhHeaAgAQLL/8KvYVWx0DAAAAABBlKDUQNQ5lZUmSbLb/fNuzSgMAgFPHFlQAAAAAgFCj1EBU8Hm9yvvyS8V36HDc9c7791uUCACA8Mdh4QAAAACAUKPUQFQo2r9f5UVFSkpLO+56WkGBRYkAAAh/rNQAAAAAAIQapQaiwuHcXLmrqhSXmFh/zfD7lXL4sIWpAAAIb8W+YvkCPqtjAAAAAACiCKUGosKB3btlM00ZhlF/reORI7J7vRamAgAgvPnkU6m/1OoYAAAAAIAoQqmBiOd2ubR/504lpqYed52tpwAAaLlyX7nVEQAAAAAAUYRSAxHv8N69qigpUdJ/lxqHDlmUCACAyFHup9QAAAAAAIQOpQYiXlF+vry1tYqJizvuOis1AABoOaffaXUEAAAAAEAUodRAxCvat0820zzuGoeEAwDQOlipAdTJzMzUxIkTlZqaqnvuuUeBQKDZz1511VX63ve+14bpAAAAgMhBqYGI5vf7dSgrS3FJScdd71hUxCHhAAC0AqePlRqA2+3W3LlzNWHCBG3atEk7d+7USy+91KxnP/jgA3388cd68MEH2zYkAAAAECEoNRDRKoqLVVlaqvjk5OOuc54GAACtw+l3BvWOdCASLV++XOXl5Xrsscc0YMAAPfzww3r++edP+pzL5dKtt96qRx55RCkpKW0fFAAAAIgAdqsDAG2ppKBArooKpXbrdtx1ztMAAKB1eOVVVaBKSUbSyW8GItT27ds1ZcoUJSQkSJJGjx6tnTt3nvS5Bx98UC6XS3a7XR9//LFmzZolwzAavNftdsvtdtd/7nTWrZLyeDzyeDytMIv26Zu5McfwFw3ztGKOfr9f8fHxsps2xcfHy+/3N+v1v3nOPPZXTrDPSgr6NYN1qnNrDdHw/SpFxzyjYY5SdMwzGuYoRcc8W2NuRoC31iGCbX7/fa147jn1HjnyuOtznn9enQ8csCgVEOV++lPp5z8P6pFX3nlFWzK3qF/Pfid8zTvVK3VqrXAATsX85Pnqbu9udQzAMnfffbdqamr09NNP119LT0/Xnj17lJqa2uAz+/bt0+DBgzVp0iTNmTNH//jHP9S7d2+99dZbDRYb999/vx544IETrr/yyiv1ZQoAAADQ3lVXV2vhwoUqLy9Xhw4dTmkMVmogoh3dt0+G7fhd1gy/XymFhRYlAgAg8pT7yik1ENXsdrtiY2OPuxYXF6fq6upGS42XXnpJGRkZWrFihWJjY3XHHXeoT58+WrFihebMmXPC/ffdd5++//3v13/udDrVq1cvzZo1S506RW677/F4tGLFCp1zzjlyOBxWx2kT0TBHKTrmacUct2/frpkzZ+qy236qfzz9oNasWaMxY8Y0+7nvPvqyJOmpuxc1+9mtW7eqoKBAb322W68/8UCznwvWqc6tNUTD96sUHfOMhjlK0THPaJijFB3zLC4ubvEYlBqIWIFAQIeys084JLwDh4QDANCqyv3lVkcALJWWlqbMzMzjrlVUVCgmJqbRZw4cOKCzzz67vgxJTk7WoEGDtHfv3gbvj42NPaE4kSSHwxGxP/B+WzTMMxrmKEXHPEM5R5vNJpfLJa/PL5fLJZvN1qzX/uY537G9O4J9VlLQrxmsU51ba4qG71cpOuYZDXOUomOe0TBHKbLn2Rrz4qBwRKyK4mJVFBefeEg4qzQAAGhVTr/T6giApSZOnKgNGzbUf56Xlye32620tLRGn+nVq5dcLlf9536/XwcOHFCfPn3aNCsAAAAQ7ig1ELGKDx2Sq7LyhJUaya2wxAkAAPwHKzUQ7WbOnKny8nL9+c9/liQ98sgjmj17tkzTlNPpbPAwxCuvvFLvvPOO3nzzTR04cED33Xef3G63pk+fHur4AAAAQFih1EDEKi0okN/nk/2/ljQllpVZEwgAgAjl9LFSA9HNbrfr2Wef1S233KKMjAy98cYbeuSRRyRJo0eP1rvvvnvCM0OGDNHf//53PfTQQxo0aJDeffdd/etf/1Lyf60yBgAAAHA8ztRAxCrat69+r89vSyottSANAACRqzJQKW/AK7vBPy0RvS699FJlZWVp06ZNmjZtmtLT0yXVbUXVmAsvvFAXXnhhiBICAAAAkYGfPBGRAoGACrKyTth6SqLUAACgLbgCLiUbvMMc0a1Hjx7q0aOH1TEAAACAiMb2U4hIFcXFcpaUnHBIuOnxKL6qyqJUAABErhp/jdURAAAAAABRgFIDEamkoECuiooTVmqwSgMAgLbhDritjgAAAAAAiAKUGohIFcXFDR4STqkBAEDboNQAAAAAAIQCpQYiUmVpqYwGrlNqAADQNmoCbD+F8Hbvvfc2+rUXX3wxhEkAAAAANIVSAxGp7MgRGaZ5wnVKDQAA2gYrNRDuVqxYccK1TZs2yefz6f/9v/9nQSIAAAAADbFbHQBoCyWHDikmLu6E64llZaEPAwBAFKDUQLgZOHCg4uPj5fV6tXTpUnXs2FHPPPOMfvjDH8o0Tc2cOVOHDx/Wxx9/rPj4eKvjAgAAADiGlRqIOF6PR86jRxssNVipAQBA26DUQLjp3Lmz4uPj9dBDD6m0tFQOh0N+v19PPvmkhgwZouHDhysmJkYJCQlWRwUAAADwLZQaiDjV5eWqdbnkaOAddUms1AAAoE1wpgbCTXx8vOLi4tSrV6/jrqekpMjhcMhuZ1E7AAAA0B5RaiDiVJaWylNTc8JKjbjKStk9HotSAQAQ2dx+VmogMni9XkmS3+9XIBBQbW2txYkAAAAAfBtvP0LEqSwtlae2Vo7Y2OOus/UUAABth+2nEAkCgYCuu+461dbW1h8SnpGRIcMwrI4GAAAA4BhWaiDiVJaWypBO+OEzwem0JhAAAFGA7acQCQzD0Msvv6zJkyfrBz/4gaZMmaLS0lKNGTPG6mgAAAAAjqHUQMSpKClRoIHrMS5XyLMAABAtWKmBSMLKDAAAAKD9YvspRJzSggI5YmJOuE6pAQBA26HUQLgpLy+X3+/Xl19+edz1vLw8VVVVqaaG1UcAAABAe8RKDUSUQCCgkoICxcTHn/C1GH4wBQCgzfjkkyfgsToG0GxxcXHq1KmTXn75ZfXq1Usul0sJCQl64okn5HQ6VVhYKI/Ho6NHj7JyAwAAAGhHWKmBiOKurpbL6ZQjLu6Er7FSAwCAtuUL+OQwHFbHAJpl/fr1x33+1FNPacmSJVqyZEn9tc8++0yJiYmqqKgIcToAAAAAjWGlBiJKZWmpamtqFNNQqcFKDQAA2lSgwVOtgPAwbdq0E65NnTpV8fHxuv/++0MfCAAAAECDKDUQUarKylRbU9PwSg1KDQAA2pRffqsjAKfsmWeeafRrF154YQiTAAAAAGgKpQYiiru6Wn6vV6b9xJ3VKDUAAADw32pra/Xggw82ec/LL7/MFlQAAABAO8GZGogotTU1kmE0eJgjZ2oAANC2WKmBcGS32/Wb3/xGBQUF6tGjh4YMGaJp06ape/fukqRt27Zp2bJl6tu3r6ZPn25xWgAAAACs1EBE8dTU6MQ6ow4rNQAAaFuBAGdqIPzYbDYlJiZqzJgx8ng8euedd3T66adrwoQJevLJJ3X++efrl7/8JYUGAAAA0E6wUgMRxd3YaoxAQA5KDQAA2hQHhSOcvP/+++rfv78GDx6s5ORk3XzzzfVfKyws1KJFi3THHXfo/PPP12233WZhUgAAAADfxkoNRBRPTU2D7xJ1NLGCA0B4sx20SR6rUwCQKDUQXp599llNnjxZvXv3VklJiV544QX9z//8j2bOnKmpU6dq2rRp2rt3r6qrq/XEE09YHRcAAADAMazUQESprqiQzTRPuM7WU0Dksu2zySg05B/qV6BXQDSYgHUM/gAijLz11lsKBAJas2aNXnvtNf3qV79Sbm6u7rnnHj388MP19/3tb3/TuHHjdPHFF6tv377WBQYAAAAgiZUaiDCuigqZ9hO7OkoNILIZtYbML02Za02p2Oo0QPQyDEoNhI9f/OIX+vnPf67du3fL7XZr8+bNuuaaa5SYmKjvfe97+uKLL+T1enXDDTfUfw4AAADAeqzUQESpqayUraFSo7GzNgBEFMNpyP6ZXf5ufvmH+aUEqxMB0cXG+2UQRq6//nq98MIL2rVrl+x2u+bNm6c5c+bo+9//vlJTU7VmzRoZhqERI0bovvvuszouAAAAgGP4yRMRpaaiQnaH44Tr9tpaC9IAsIqtwCZzlSnb1zbJa3UaIHqw/RTCySOPPKLS0lIdOHBAX3zxhdLT03X48GFVVVUpPT1d27dvV8+ePbVlyxY5nU6r4wIAAAA4hlIDEcPv96umurrBlRo2v9+CRACsZPgN2bLqyg3jIL9oBUKBUgPhJD09XRkZGUpNTdXWrVtVUVGhLl26aOzYsXI6ncrLy1NhYaGWLl2qH/3oR1bHBQAAAHAMpQYihqemRj6vt8EzNYxAwIJEAFqLaZiqqamRszL4d8oaNYbMrabMdaZU1vrZAPwHpQbCyW233aaNGzdq4MCBOvvss5Wbm6sZM2Zo5cqVcrlcmjNnjlJTU3XXXXdp7dq1OnTokNWRAQAAAIhSAxGktqZGPo+HUgOIQGdOOVMzJs5QubNcufty5Xa7gx7DKDVkfmrKtt0m1bRBSACcqYGw8vzzz2vatGkaOHCgevbsqb///e9avHix4uPjlZKSoh07duh3v/udDMPQggUL9Pbbb1sdGQAAAIA4KBwRpLaplRpsPwWEtYzOGVpw4QKNGz5OH3/2sfbs3aO42Dh1S+8m0zSbPY4hQ8Z+Q8YhQ/7BfgX6BqTmPw7gJBzGiedaAe3VPffcI0kqKyvThAkT1LdvXz3zzDNKSUnRb37zGzkcDo0cOVKSdPPNNys9Pd3KuAAAAACOodRAxKh1uepKjQYOCmelBhD+DMPQkP5D1L9Xf23ZsUWrNqxSzr4cpaWkqVNKJxlG87e9MXyGzF2mAvkB+Yf7FejK3xFAS8UoRjaDlRoIPykpKUpJSZEknX322ZKkK6+88rh7KDQAAACA9oNSAxHD43bL7/XK1sC7tlmpAUQOh8OhyWMna9jAYVq/eb3Wb1mv7PxsdevSTUkJSUGNZVQbMjeZ8nf2yz/cL3Voo9BAFIi1xVodAWi2srIyTZkyRbt375YkzZs3T0ePHpXNdmIxZxiGFi1apBtuuCHUMQEAAAA0gFIDEcPv8ykQCMho4IdRsVIDaD+Ki1tlmA5JHXTeGedp1JBR+mTDJ9q+e7uOlhxV94zuinHEBDWW7ahNxlpDgT4B+Qf7peAeByAp1qDUQPhISUmRx+Op/3z79u1avXq1Asf+zVhQUKA//OEPuuGGGxQbG6vFixdTagAAAADtBKUGIkYgEKgrNRragiaIbWkAtLE//EHKzpZ+9ztp+PAWD9ejaw8tvHihxo0Yp4/Xf6ycfTlKTEhU185dG3zHbWOMgCEjz5Bx0JB/iF+B3gFx5jHQfJQaCDdOp1NPPPGEAoGAnE6nli9frsTERH300Uf68MMPtWTJEvXt21edOnXStddea3VcAAAAAMfw6xpEjEATW0wFKDWA9uXDD6UxY6Tbb5dKS1s8nM1m04hBI3TT1Tdp/vnzlRCXoKy8LJWWl9a/67a5DI8hM9OUudaUUcTfHUBzxRlxVkcAguL3+1VWVqaysjL5fD4dPnxYn332mY4cOaKqqiotX75cf/3rX1VZWakf//jHVscFAAAAcAylBiJGUys1AkG8WxtAiHi90pNPSoMG1a3e8PlaPGRsTKymnzZdty6+VWdPP1sut0s5+3JU7aoOeiyjwpC50ZTtC5tU1eJoQMRjpQbCTVxcnE477TSddtppiouL05w5c3TDDTcoIyNDU6ZM0VNPPaXs7Gz5OZsNAAAAaFfYfgoRI+D3N3p2Bis1gHasuFi67TbpmWekxx+XzjqrxUOmdkzVJbMv0dhhY/XJZ58oc0+mbDabumd0l8PuCGos22GbjCOGAv0D8g/0S8E9DkQNSg2Em8rKSr3xxhsKBAKqqKjQL37xC5WWlmrv3r2qrq7Wb3/7W82bN08ZGRlWRwUAAADwLZQaiBjfbDHT4EoNSg2g/fvqK+nss6VLL5UefVTq37/FQ/bp0UfXXHaNMvdk6uPPPtbe/XvVIbmDuqR1Cf68jRxDxgFD/qF+BXoGJP5aAY7D9lMIJ16vV506ddILL7wgSfr0009111131f97sry8XKtWrdIHH3ygbt26SZJmzpxpWV4AAAAA/0GpgcgRCDR6IDjbTwFh5J//lJYvl+66S/rxj6WkpBYNZ5qmxgwbo0H9BunzbZ9rzRdrlJWfpa6du6pjcsegxjLchsztpgJ5AflG+KS0FkUDIgorNRBOfD6fpk6dWv/5mWeeqd/97ncyTVNlZWVKTU1VeXm5kpOT9cQTT6i2tpZSAwAAAGgnKDUQMZo6DJiVGkCYcbulRx6R/vQn6eGHpeuua7S0bK6EuASdOeVMjRw8Uqs3rtamzE06WnJUPbr2UFxscO8wN8oN2dfb5e/ul3+YX4pvUTQgIsTaKDUQPmJjY/Xyyy9rwYIFuvrqq/XHP/5RklRTU6MhQ4YoPz9f9957ry655BJNmzbN4rQAAAAAvo1SAxHDsNkaPVPDZ+dbHQhLBQXS9dfXHST+xBPSlCktHrJzWmddft7lGjt8rFZ+tlK7c3YrxhGjbl26yW4G93eF7ZBNRqEh/0C/AgMCktnieEDYYvsphJNPP/1UQ4YMkd/vV3x8vK6//noVFRXJMAyVlJTo4osvVn5+vlasWKHu3bvL4/Hogw8+sDo2AAAAAFFqIIJ8c5ZGIBA44VwNTxy/aAHC2hdfSNOmSQsXSr/6ldSjR4uGMwxDA/oMUO8evbV913Z98tknyt2Xq9QOqeqc1rnBs3kaHctvyNxjKrAvIP9wvwLdG181BkQytp9COPnZz36mdevWyeFwyDRNDRkyRIsXL1ZGRobOP/98/fKXv1ROTo5+//vf66GHHpLH47E6MgAAAIBjOGgAEcOw2RrdnqY2nr1hgLAXCEgvvywNGSI9+KBUU9PiIR12h04bdZqWLVqmi866SAEFlJWXpYrKiqDHMmoMmVtMmetNqbzF0YCwQ6mBcLJy5Uo5nU5Nnz5dHTt21K5du7Ro0SItXrxYlZWVGjFihM477zzt2LFDo0aN0sSJE62ODAAAAOAYVmogYhiGIUMNr9SoZaUGEDmqqqT//V/phRekX/9amj+/xUMmJSbpnBnnaNSQUfpkwyfatnObikqL1COjh2JjgvtFrVFiyFxrKtA7IP8Qv8TveREl2H4K4SYmJkbXXHONTjvtNA0ZMkSBQEDvvfeeNm/eXP/vyR//+Mey2XgfGAAAANCe8C90RIwmV2pQagCRJy9PuvJK6YwzpG3bWmXIruldddVFV+n6+ddrQO8B2l+wXwcLD8rn8wU1jiFDtn02mZ+YMnIMyd8q8YB2y5SpeINVkQg/ixYt0pAhQyTVvUHmwgsv1P/+7//KMAwdOnRIP/jBD4LakhAAAABA26PUQMQwDEOGYSjQwGHhfrtdXg4LByLTmjXShAnSTTdJRUUtHs4wDA3tP1RLFyzVggsXqENyB+Xsy1FxaXGDf780OZbXkLnLlLnalHGYX4ohcnWwdeAXvwhLpaWliomJkSS5XC4NHz5cfn9dEx0TE1P/NQAAAADtB6UGIobNNOt+odLILx05VwOIYH6/9Mc/SoMGSY89JrXCga4Oh0NTxk3RskXLNOf0OfJ4PcrOz1ZVdVXQYxlVhswvTNk22qTgj+sA2r2Oto5WRwBOSVxcnGJj6/YJdDgc+vrrr+u3m7LZbHI4HFbGAwAAANAASg1EDEdsrGx2u3xeb4NfZwsqIAqUl0t33y2NGiW9916rDNkxuaMunHWhbl54s8aPHK+ikiLtPbBXtZ7aoMeyFdlkrjFl22GTgn8caLc6mB2sjgCckm8XF3a7vb7gAAAAANB+UWogYsTExclsqtRgpQYQPb7+WrrwQumCC6Tdu1tlyJ5de2rxJYt17eXXqk/3Pso/mK+CIwX125Q0lxEwZNt77LyNPM7bQGRgpQYAAAAAIFQ4ZAARIyY+vq7UaGTbGVZqAFFo+XLpo4+k226TfvYzKSWlRcPZbDaNGjJKg/oO0qavNmn1xtXKzs9Welq6UjqkBHWmgOExZGaaCuQH5B/hV6BzcOd1AO0JpQbCUUlJiRITE1VWVqbu3bsrNjZWbrdb/fv3lyT5fD45nU7169dPNTU1KigosDgxAAAAAIlSAxHkZCs1PJQaQHTyeKTHH5defll68EFp6VLJ1rKFinGxcZpx2gwNHzhca75Yoy+2f6GjZUfVI6OHEuISghrLqDBkbjDl7+qXf5hfSmxRNMASHWxsP4Xw4na7NWLECM2dO1dxcXH629/+ppiYGJ155pl6/fXXJUlHjx7VlVdeqddee01ut9vixAAAAAC+wfZTiBiOuDiZDof8nKkBoCFFRdItt0jjx0urVrXKkGkpabpk9iVaetVSjR4yWoVFhco/mC+PN/iDym2FNpmrTdl226SG/xoD2q2OJis1EF5iY2P173//WzU1NfJ6vaqurtaUKVMUCAQ0YcIETZgwQWPHjpVpmpo4caJmzJhhdWQAAAAAx1BqIGLYbDbFJiRwpgaApm3fLs2aJc2bJ+XltXg4wzDUt2dfXXf5dVp86WJ1Te+qvfv36vDRw8Gft+E3ZMs+dt7GAUNiRyqEgXgjXjFGjNUxgKBNmDBBzz77rOx2u37+85/rvffek9frlc/nszoaAAAAgCZQaiCixCUmNl5qsFIDwLe9+aY0bJj0k59IVVUtHs40TY0bPk63LLpFl55zqeymXVn5WSqvKA96LMNtyNxmylxnSqUtjga0KbaeQrhzOBxauXKlnn/+eUnSrl27LE4EAAAAoCmUGogo8cnJjR8UzkoNAP+tpkb6xS+kwYOlv/xFCrR8aURCXIJmTZ2lZYuW6fTTTldFZYVy9+Wqxl0T9FhGmSFznSnbVpsU/ONASHBIOMKZx+OR1+tVfHy8/vKXv2js2LFyOp2SJL/fL28jb5YBAAAAYB1KDUSU+OTkRldquJKSQpwGQNg4dEi69lpp2jTp889bZcj0Tumad/483XjljRrcf7AOHj6o/QX7g97WxJAh28FjW1JlGRK7oqCd4TwNhDPDMDRv3jxJUkJCgjZv3qxp06ZJqis8ampolAEAAID2hlIDESU+OVn+Rn5hWJWSEtowAMLPhg3SlCl1BUdBQYuHMwxDA/sO1A3zb9DVc69WWkqacvblqKikSIEgV4UYPkPm16bMVaaMAqPF2YDWwvZTCGdJSUn605/+1ODXMjIytGrVqtAGAgAAAHBSlBqIKDHx8ZLR8C/7qlJS5G/kawBQLxCo24pq8GDp4Yclt7vFQzrsDk0cPVHLFi3TBWdeoEAgoKy8LFVUVQQ9luEyZG42ZfvMJjlbHA1oMbafQqSKjY2tX7UBAAAAoP2g1EBEiYmLU2O1hd805UpODmkeAGGsslL68Y/rDhN/661WGTI5MVnnzjxXtyy8RZPHTlZJWYn27t8rd23wxYmt2CZzjSnblzap5b0LcMrYfgoAAAAAEEqUGogoMXFxampDl8rU1JBlARAh9u6VrrhCOuss6auvWmXIbl266eq5V+v6ederX69+2l+wXwcPH5TPfwrnbew7dt5GriH5WyUe0GxxRhzbTwEAAAAAQopSAxElJj5eCgQa3aueUgPAKfvkE2ncOGnZMuno0RYPZxiGhg0cpqULlurKC65UcmKysvOyVVxWHPx5G15D5k5T5mpTxhG22UPodDG7WB0BAAAAABBlKDUQUWLi42UzTQ4LB9A2fD7pmWfqztv4/e8lr7fFQ8bExGjq+Km6dfGtmnP6HNV6apWdn60qV1XQYxlVhszPTdk+t0mVLY4GnFQXO6UGAAAAACC0KDUQURJTUhQTF6fampoGv85KDQCtorRUuvNOafRo6YMPWmXIjskdddFZF+nmq2/W+BHjVVRcpLwDefJ4PEGPZTtik7nalG2HTQr+caDZWKkBAAAAAAg1Sg1ElKTUVMXEx8tDqQEgFHbtks47T7roIikrq1WG7NWtlxZfuljXXn6tenbrqbyDeSosKpTfH9yBGUbAkG3vsfM28g01eeAQcIooNQAAAAAAoUapgYgSl5iouORk1bpcDX6dUgNAm3j3XWnECOkHP5CczhYPZ7PZNGrIKN101U26/NzLFRsTq+z8bJU6S4M/b6PWkPmVKXOtKRW3OBpQL86IU0ezo9UxAAAAAABRhlIDEcUwDKV17dro9lM1SUnyOhwhTgUgKng80qOPSoMGSX/8oxTkyoqGxMfFa+akmVq2eJnOmHyGql3VytmXI1dNw8VtUwynIftndtk226TqFkcDlG6mWx0BAAAAABCFKDUQcVK7dZPH7W7065UcFg6gLR05It10k3TaadLata0yZKeUTrpszmVaumCpRg4eqYKiAuUfzJf3FA4qtxXYZK4yZfvaJrX8nHNEMbaeAgAAAABYgVIDESe5UycZTXydLagAhMTWrdLMmdKCBdK+fS0ezjAM9evVT9ddcZ0WXbJIGZ0zlLs/V0eKjwS/JZXfkC2rrtwwDjb1NybQuAx7htURAAAAAABRiFIDESfpWGnR2C/5KDUAhNRrr0lDh0o/+5lU3fJ9n+ymXeNHjNeyRct08eyLZTNsysrLkrMy+LM8jBpD5lZT5qemVNbiaIgyrNQAAAAAAFiBUgMRJyk1VabDIW9tbYNfp9QAEHIul/Tzn0tDhkivvNIqQybEJ+jsaWdr2eJlmj5+usorypW7L1fuJrbfa4xRZsj81JRtm01q+Egi4DixRiyHhAMAAAAALEGpgYiTmJKimPh41boaPki3vAvvLAVgkQMHpEWLpBkzpE2bWmXILp26aP6F83XD/Bs0qN8g7S/crwMFB+Tz+YIax5Ah2wGbzE9MGdmGFNzjiDKs0gAAAAAAWIVSAxEnKTVVMXFxqq1p+O3GJd26hTgRAPyXdeukSZOk66+XCgtbPJxhGBrcb7BunH+jrp57tVI6pignP0dHS44Gf96Gz5C525S52pRRyHkbaBilBgAAAADAKpQaiDh2h0PJnTs3Wmp44uJUwRZUAKwWCEgvvSQNHiz96ldSI1vmBcPhcGjSmElatmiZzp91vnx+n7Lzs1VZVRn0WEa1IXOTKdtnNin44zoQ4brYKTUAAAAAANag1EBESuvWTZ5Gtp+SpJLu3UOYBgCaUFEh/ehH0ogR0r/+1SpDdkjqoPNmnqdbFt6iiaMnqrisWHsP7FWtJ/jixFZsk7nGlO0rm9Ty3gURopudVY8AAAAAAGtQaiAipWRkNLmfPFtQAWh3srOlSy+VzjlH2rGjVYbsntFdV8+9WkuuWKK+Pfoq/2C+Dh0+JJ//FM7byD923sZeQ/K3SjyEqVRbqpJtyVbHAAAAAABEKUoNRKSk1FQ1tRM8pQaAduujj6QxY6TvflcqKWnxcDabTcMHDdfSq5Zq/gXzlZiQqOz8bJWUlwR/3obHkLnDlLnGlHGE8zaiVW9Hb6sjAAAAAACiGKUGIlJyp04ybDb5vN4Gv06pAaBd8/mkp5+WBg2SnnxSauTvsmDExsRq+oTpunXxrZo9fbbcbrey87NV7aoOeiyj0pD5uSnb5zapqsXREGZ62yk1AAAAAADWodRARErr1k3xyclyVVQ0+HVPfDyHhQNo/0pKpNtvl8aOrVvB0QpSOqTo4rMv1k1X36Sxw8fqcPFh5R/Ml8frCXos2xGbzFWmbDttUvCPIwzZZFMPRw+rYwAAAAAAohilBiJScqdOSkpNVU1lZaP3sFoDQNjYsaPurI1LLpFyclplyN7de+uaS6/RtZddq+5dumvv/r0qLCqU3x/cgRlGwJAt99h5G/sMKbgdrRBmMswMxRqxVscAAAAAAEQxSg1EJJvNpm6DBjW6UkOi1AAQht5+Wxo+XLr3XqmJv9+ayzRNjR46WjcvvFmXn3u5Yhwxys7LVpmzLOixjFpD5pemzE9NqeVHgaCd4jwNAAAAAIDVKDUQsbr07t3kO45LuncPYRoAaCW1tdKvfy0NHiy98IIU5GHfDYmPi9cZk8/QssXLNHPyTFVVVyknP0euGlfQYxnlhuzr7bJtsUnBP452rpejl9URAAAAAABRjlIDESute3fZmjgsvJSVGgDCWWGhdOON0qRJ0vr1rTJk59TOuvzcy3Xjghs1bNAwHTpySPsO7ZPXF/xB5bZDx7ak2mNIvlaJB4vFKEbdTP6/EwAAAABgLUoNRKzUbt0Ul5QkVyPnatTGx6syJSW0oQCgtW3aJE2fLi1cKO3f3+LhDMPQgN4DdP2867X4ksXq0qmLcvfl6kjxEQWCXBVi+A2Ze8y6cuOg0eJssFYPRw/ZDP7pCAAAAACwFj+ZImJ16NxZSWlpqmnqXA22oAIQKV59VRo6VHrgAcnV8n2f7KZd40eO1y0Lb9Hcs+fKMAxl5WXJWekMeiyjxpC51ZS5zpTKWhwNFult5zwNoCmZmZmaOHGiUlNTdc899wRVBHs8Ho0aNUqrVq1qu4AAAABAhKDUQMSy2WzqPnBgk4eFF1NqAIgk1dXS/ffXlRt//3urDJmYkKjZ02dr2aJlmjp+qsqd5crdlyu32x30WEapIfNTU7btNqmmVeIhhDhPA2ic2+3W3LlzNWHCBG3atEk7d+7USy+91Oznf/3rXyszM7PtAgIAAAARxG51AKAtpZ/ksPDCfv1CmAYAQmTfPumqq6Snn5Yef1waP77FQ2Z0ztCCCxdo3PBx+nj9x9qTt0dxsXHqlt5Npmk2exxDhoz9howCQ/5BfgX6BqTmPw6LJBlJ6mR2sjoG0G4tX75c5eXleuyxx5SQkKCHH35Yt912m66//vqTPpuVlaXf/va36tu3b5P3ud3u4wplp7Nu5ZzH45HH42lR/vbsm7kxx/AXDfO0Yo5+v1/x8fGymzbFx8fL7/c36/W/ec48tkNosM9KCvo1g3Wqc2sN0fD9KkXHPKNhjlJ0zDMa5ihFxzxbY25GINgNsoEwkrttm177xS/UY8gQmfYGOrxAQJf/5jeKa4WtWgCgXbLZpOuvlx5+WOrSpVWG9Hg82rJji1ZtWKVDRw6pU0onpaWkyTCCPzcjkBCQf7hfga78c6Q9GxYzTHMS51gdA2i3HnjgAW3cuFHvvfeeJCkQCKhTp04qKSk56bNnnXWWzj33XC1fvlz333+/zjzzzAbvu//++/XAAw+ccP2VV15RQkJCi/IDAAAAoVJdXa2FCxeqvLxcHTp0OKUxWKmBiJbarZvik5PlqqxUUkOHghuGDvfrpz47d4Y8GwCEhN8vPf+89Prr0k9/Kt1+uxQT06IhHQ6HJo+drGEDh+nTTZ/qsy2fKTs/W926dFNSQlJQYxnVhsxNpvyd/fKP8EvJLYqGNtLH0cfqCEC75nQ61e9bK4ANw5BpmiotLVVqamqjz7344osqLy/X3XffreXLlzf5Gvfdd5++//3vH/eavXr10qxZs9SpU+SupPJ4PFqxYoXOOeccORwOq+O0iWiYoxQd87Rijtu3b9fMmTN12W0/1T+eflBr1qzRmDFjmv3cdx99WZL01N2Lmv3s1q1bVVBQoLc+263Xn3ig2c8F61Tn1hqi4ftVio55RsMcpeiYZzTMUYqOeRYXF7d4DEoNRLSO6elKSk1VVVlZw6WGpML+/Sk1AEQ+p1O65x7p2WelRx+V5s5t8ZAdkjrogjMv0JihY/Txho/15a4vVVRcpB5deyjGEVxxYjtqk7HGUKBPQP7BfqllvQtakSlT/Rxs1wg0xW63KzY29rhrcXFxqq6ubrTUKCoq0n333af3339f9oZWFP+X2NjYE15DqiuaI/UH3m+LhnlGwxyl6JhnKOdos9nkcrnk9fnlcrlks9ma9drfPOc7tlg22GclBf2awTrVubWmaPh+laJjntEwRyk65hkNc5Qie56tMS8OCkdEs9ls6jZgQJOHhRcOGBDCRABgsaws6eKLpfPOk3btapUhe3TtoUUXL9KSeUvUp0cf5R/M16Ejh5o806ghRsCQLc8m8xNTRp4hBfc42khfR1/FGLRMQFPS0tJUVFR03LWKigrFNLEy7s4779SNN96osWPHtnE6AAAAILJQaiDidenbt8lfrFWlpKiiiW0BACAiffCBNHq0dMcdUmlpi4ez2WwaMWiEbrr6Js0/f74S4hKUnZ+t0vJSBXt8l+ExZGaaMteaMoqCP6cDrWtwzGCrIwDt3sSJE7Vhw4b6z/Py8uR2u5WWltboM6+88oqefPJJpaSkKCUlRZ9++qkuuugiPfLII6GIDAAAAIQtSg1EvPTevWXa7fK43Y3eU9i/fwgTAUA74fVKTzwhDRok/eEPks/X4iFjY2I1/bTpunXxrTpr2llyuV3K2Zejald10GMZFYbMjaZsX9ikqhZHwymwy87WU0AzzJw5U+Xl5frzn/8sSXrkkUc0e/ZsmaYpp9Mpj8dzwjN79+7Vl19+qW3btmnbtm067bTT9Nxzz+mWW24JdXwAAAAgrFBqIOJl9OunpNRUVTbxTmRKDQBRrbhYuu02adw46eOPW2XI1I6pumT2Jbrpqps0ZugYFR4tVP7BfHm8J/5i72Rsh20yV5uy7bJJ3laJh2bq5+gnhxGZ+7gCrclut+vZZ5/VLbfcooyMDL3xxhv1Ky5Gjx6td99994Rn+vbte9xHXFycunbtqpRGzoEDAAAAUIeDwhHx4hIT1WvYMO1at06pXbs2eE9hv37yG4ZsQW6RAgAR5auvpLPPli67rO4w8X4tf4d+nx59dM1l1+irr7/SJxs+0d79e9UhuYO6pHWpP2SyOQy/ISPHkHHAkH+oX4GeAYmdqdocW08BzXfppZcqKytLmzZt0rRp05Seni6pbiuq5li1alXbhQMAAAAiCCs1EBV6Dhsmn9fb6L7unvh4lXbrFuJUANBO/eMf0rBh0n33SZWVLR7ONE2NHT5WNy+8WZfNuUwOu0NZ+VkqrygPeizDbcjcbsr81JRKWhwNTYhRjPo6+lodAwgrPXr00CWXXFJfaAAAAABofZQaiApd+/dXbEKC3NWN7+lewBZUEWWv1QGAcOd2S488Ig0eLP3pT1IrrGRLiEvQmVPO1K2LbtUZE89QRVWFcvJzVOOuCXoso9yQud6UbatNcrU4GhrQL6af7AaLegEAAAAA7QulBqJCeu/e6tC5sypLGn9bb+GAASFMFF1+JGluENcbcr/qdpr5749Vkj6SlC7pl8fu3SVpwymnBXCcggJpyRJpyhRpQ+v8yeqc1lmXn3e5vnPldzR04FAdPHxQ+wv2y+sL7sAMQ4ZsB20yV5ky9hhSy885x7cMdrD1FAAAAACg/aHUQFSwOxzqM2qUqp3ORu852quXvA4OQ21tmZL+IOnxZl5vzI8klX7rY7vqioxxkv6fpGePfUjSG5KuaEFmAA34/HNp2jTpmmukgwdbPJxhGBrQZ4Cun3e9Fl68UJ1SOil3X66KSooa3Sqw0bF8hsw9psxVpoxDHLTRGmKMGPVx9LE6BgAAAAAAJ6DUQNToMXiwAoGA/H5/g1/3m6aO9OEXOK0pIOlmSXdKGtCM602Jk5TyrY+nJN0lqaPqttUfc+y+KkkOSTGnHhtAYwIB6a9/lYYMkR56SKoJftuo/+awO3TaqNO0bNEyXTjrQgUCAWXnZ6uisiLosQyXIXOLKXO9KQV/XAe+ZYBjgEzDtDoGAAAAAAAnoNRA1Og6YIASkpPlamK1xv6hQ0OYKPL9UdI2Sf0k/VuS5yTXm+uQpH9I+t6xz5MlHVFdWfI3SVe1IDOAZqiqkn7607rDxN94o1WGTEpM0pzT52jZomWaPHaySp2lyt2fK3etO+ixjBJD5lpTti9tUvCPQ9LgGLaeAgAAAAC0T5QaiBqpXbsqrXt3VZaWNnrPgWHD5Lfxx6I1VEr6iaRBkg5IekzSzCauB/N+72ckLZSUdOzzBcfGuFBSnqS+LQ0PoHny8qT586Uzz5S2b2+VIbumd9VVF12l6+dfr/69+mt/wX4dLDwony+4AzMMGbLts8n8xJSRY0gNL9JDA+KMOPWy97I6BgAAAAAADeK3t4gahmGo35gxqqmsbPQed0KCDvfrF8JUkest1W0F9bGkn0r6UFKZ6kqMhq7/uZnj+lS30uOWb127WlKRpMWSRks6+9iHq2VTANBcq1dL48dLN98sHT3a4uEMw9DQ/kO1dMFSLbhwgZKTkpWzL0fFpcXBn7fhNWTuMmWuNmUc5ryN5hjoGMjWUwAAAACAdotSA1Gl64ABstls8nm9jd6TP2JECBNFrgOSJktKO/a5XXWFw88aub63meN+IqmzpGH/db2jpPdVd/ZG52Mfn5xidgCnwO+Xnn1WGjRI+t3vJE+wG8udKCYmRlPGTdGti2/VnNPnyOP1KCsvS1XVVUGPZVQZMr8wZdtok4I/riOqjIodZXUEAAAAAAAaRamBqNJ1wAAlpqY2uQXV/qFD5WMLqhbrpRNXSuRL+nkj15t7RPtrki5r4Hqx6oqSMklDjn0UN3NMAK2orEz6/velUaOk5ctbZciOyR114awLdfPCmzVh1AQVlRQp70CePKdQnNiKbDLXmLLtsEm1rRIvomSYGepi72J1DAAAAAAAGsVvbhFVklJSlNGvn6qaKDU88fEqHDAghKki04WSdqnu/IsDkp5Q3eHgjV0/79hzTjV9cPj7kmY1cP1l1Z2zkaK6kiRfUmqLZgCgRb7+WrrggrqPr79ulSF7du2pxZcs1rWXX6te3Xop72CeCo4UyO8P7sAMI2DItvfYeRv5hhTcjlYRbXTsaKsjAAAAAADQJEoNRJ1+Y8aotqamyX3Z2YKq5dJUV0D8RdJgSY9L+puk8Y1c73vsudGS3m1kzBxJhyRNbOBrHknpks6UlHns48yWTQFAa1i+vG7Vxl13SeXlLR7OZrNp1JBRuunqm3TFeVcoLi5O2fnZKi0vDf68DY8h8ytT5hpTxlHO24gz4jQ4ZrDVMQAAAAAAaJLd6gBAqPUeMULxycmqdjqV2LFjg/ccGDpUPtOU6fOFOF1kmSJpXRDXJSmvifEGSGrsNJS7j/1vsqTNzQkHIHQ8Hunxx6WXX5YefFBaulRq4TZ/cbFxOn3i6RoxaIRWf75am77cpKNlR9Ujo4cS4hKCGsuoMGRuMOXv6pd/uF8K7vGIMTxmuOwG/zQEAAAAALRvrNRA1Env3Vtd+/dX+ZEjjd7jjY3VoYEDQ5gKAKJAUZF0yy3ShAnS6tWtMmRaSpouPedSLb1qqUYNHqXDRYeVfzBfHu8pnLdRaJO5ypRtt63xBjWCsfUUAAAAACAcUGog6hiGocGTJ8vjcjW5Vck+tqACgLaxbZt05pnSvHlSXl6LhzMMQ3179tWSK5Zo0aWL1DW9q/bu36vDRw8HvyWV35At+9h5Gwei57yNPvY+6mg2vHoRAAAAAID2hFIDUan3iBGK79BBVU3s735wyBB57WzDAQBt5s03pWHDpJ/8RKqqavFwpmlq3PBxumXhLbrknEtkN+3KysuSs8IZ9FiG25C5zZS5zpRKWxyt3WOVBgAAAAAgXFBqICp17tlT3QYOlLOpLahiYnRoMAemAkCbqqmRfvELacgQ6a9/lYJcWdGQhPgEnTX1LC1btEzTJ0xXeWW5cvJzVOOuCXoso8yQuc6UbatNCv7xsJBsS1Y/Rz+rYwAAAAAA0CyUGohKhmFo8KRJqq2paXJrkny2oAKA0Dh4ULrmGmn6dOmLL1plyPRO6Zp/wXx958rvaMiAITp4+KD2F+yXz+cLahxDhmwHj21JlWVIwT3e7o2KGSXDMKyOAQAAAABAs1BqIGr1HjFCiSkpqiora/SeQ4MGyRMTE7pQABDtPvtMmjxZuu46qaCgxcMZhqGBfQfqhvk36Oq5VystJU05+3JUVFIU/HkbPkPm16bMVaaMgsgoAUyZGhFLgQ8AAAAACB+UGohaad27q/ugQSpvYgsqn8PBag0ACLVAQPrzn6XBg6Vf/lJyu1s8pMPu0MTRE7Vs0TJdcOYFCgQCysrLUkVVRdBjGS5D5mZTts9sUvDHdbQrA2MGKsGWYHUMAAAAAACajVIDUcswDA2aOFEet1t+v7/R+7ImTgxhKgBAvcpK6X/+Rxo+XHrrrVYZMjkxWefOPFe3LLxFk8dOVklZifbu3yt3bfDFia3YJnONKdtXNqnlvYslOCAcAAAAABBuKDUQ1fqMHKmk1NQmt6Aq7dZNR3v0CF0oAMDxcnOlK66Qzj5b+uqrVhmyW5duunru1bp+3vXq16uf9hXs06HDh+Tzn8J5G/nHztvINaTGO/J2p4vZRd3t3a2OAQAAAABAUCg1ENVSMjLUY8gQOZvYgkqSsk47LUSJAACN+vhjadw46dZbpeLiFg9nGIaGDRympQuWasEFC5SYmKjsvGwVlxUHf96G15C505S5xpRxJDzO25gUN8nqCAAAAAAABI1SA1Htmy2ovB5Pk1tQ5Y8cqZr4+BAmAwA0yOeT/u//pEGDpCeekLzeFg8ZExOjqeOn6rbFt2nO6XNUW1ur7PxsVbmqgh7LqDRkfm7K9rlNqmxxtDaTbqarv6O/1TEAAAAAAAgapQaiXu8RI5SYmqrKkpJG7/Hb7codOzZ0oQAATSstle64Qxo9Wvrww1YZsmNyR1101kW66eqbNG74OBUVFynvQJ48Hk/QY9mO2GSuNmXbaZOCf7zNTYybKMMIjxUlAAAAAAB8G6UGol5Kly7qM3Kkyk+2BdXEiQpuMxIAQJvbtUs691xp7lwpK6tVhuzdvbeuuewaXXv5terZraf2HtirwqLCJlf0NcQIGLLlHjtvY5+h9vJ/Ip1snTTQMdDqGAAAAAAAnBJKDUDS8OnTJUket7vRe6pSU1UwkF8CAUC79O9/SyNHSj/4geR0tng4m82mUUNG6aarbtIV512h2JhYZednq8xZFvx5G7WGzC9NmWtNqeVHgbTYpPhJrNIAAAAAAIQtSg1AUt/Ro5Xeu7dKCgqavI8DwwGgHautlR59tO68jeeek4JcWdGQ+Lh4zZw0U8sWL9MZk89QlatKOfty5KpxBT2W4TRk/8wu22abVN3iaKckzZamQY5B1rw4AAAAAACtgFIDkOSIjdWoM8+Uy+lscnuRg4MHq7JjxxAmAwAE7cgRaelSaeJE6dNPW2XITimddNmcy/SdBd/RiEEjVHCkQPkH8+U9hYPKbQU2matM2b62SS0/5zwoE+M5SwMAAAAAEN4oNYBjBk6cqOS0NFUUN7E3iGEoe8KE0IUCAJy6LVuk00+XFiyQ9u1r8XCGYah/r/5aMm+JFl26SBmdM5S7P1dHio8EvyWV35Atq67cMA6GpmRItaVqiGNISF4LAAAAAIC2QqkBHJOakaFBEyeq7PDhJu/LGT9ePtMMUSoAQIu99po0dKj0s59J1S3f98lu2jV+xHgtW7RMF8++WIZhKCsvS87K4M/yMGoMmVtNmetMqazF0Zo0MY5VGgAAAACA8EepAXzL0GnTZHc4VFNV1eg97sRE7R8+PISpAAAt5nJJP/95Xbnx6qutMmRCfILOnna2bl18q6aPn67yinLl7suV2+0Oeiyj1JD5qSnbNptU0yrxjtPR1lFDYlilAQAAAAAIf5QawLf0GjZM3QcNUsmhQ03et2fixBAlAgC0qv37pYULpRkzpM2bW2XILp26aP6F83XD/Bs0qN8g7S/crwOFB+Tz+YIax5Ah2wGbzE9MGdmGFNzjTZoYN1E2g3/2AQAAAADCHz/dAt9i2u0aecYZqq2pafKXUUd79dLhPn1CmAwA0KrWrZMmTZJuuEE6ybaDzWEYhgb3G6wb59+oq+derZQOKcrZl6OjJUeDP2/DZ8jcbcpcbcoobPl2UR1sHTQsZliLxwEAAAAAoD2g1AD+y4AJE5SSkaHyk/ySK3PmzBAlAgC0Cb9fevFFadAg6de/lmprWzykw+HQpDGTtGzRMp1/5vny+X3Kzs9WZXVl0GMZ1YbMTaZsG2xS8Md11GOVBgAAAAAgkvATLvBfklJSNHz6dDmPNv3u2sP9++tIr14hTAYAaBMVFdK990ojRkj/+lerDNkhqYPOm3mebll4iyaOnqji0mLtPbBXtZ7gixPbUZvMNaZsmTYpyMfTbGkaHsM5UAAAAACAyEGpATRg8OTJiktKUrWz6bfG7mC1BgBEjuxs6dJLpTlzpB07WmXI7hnddfXcq7XkiiXq26Ov8g/m69DhQ/L5T+G8jbxj523sNSR/8547PeF0VmkAAAAAACIKP+UCDeg2YIB6jxih0pMcGF4wcKCO9ugRolQAgJBYsUIaO1b63vekkpIWD2ez2TR80HAtvWqp5l8wX4kJicrOz1ZJeUnw5214DJk7TJlrTBlFTZ+30cfeR30dfVuQHAAAAACA9odSA2iAYRgacfrp8vv98p5kj3XO1gCACOT1Sk89VXfexlNPSb7gVlY0JDYmVtMnTNeti2/V7Omz5Xa7lZ2frWpXddBjGZWGzI2mbF/YpKoGvi5DMxJmtDgzAAAAAADtDaUG0Ij+48apS9++OnrgQJP3HRo8WMXduoUoFQAgpEpK6lZsjB0rrVzZKkOmdEjRxWdfrJuuvkljh43V4aOHlX8wXx6vJ+ixbIdtMleZCmQG5K/9z55UI2JGqLPZuVXyAgAAAADQnlBqAI2IjY/X+HPPlbuqSl5P079oyjzjjBClAgBYIjNTmj277syNnJxWGbJ399665rJrdO3l16p7l+7au3+vCosK5fc388CMY4yAoYL1BQqsCGiIfYhijBhNjZ/aKhkBAAAAAGhvKDWAJgydOlVd+vZV8UlWaxwcMkQlXbuGKBUAwDL/+pc0fLh0771SRUWLhzNNU6OHjtbNC2/W5ederhhHjLLzs1XmLGv2GG63W7WeWs0YNUPnJZ+nJR2WKMGW0OJsAAAAAAC0R5QaQBPiEhM1/txz5aqsPPlqDc7WAIDoUFsr/frX0uDB0osvSkEe9t2Q+Lh4nTH5DC1bvEwzJ81UVXWVcvJz5KpxnfTZg0cOanDfwRo3fFzdWLb4FucBAAAAAKC9otQATmLotGnq0ru3ig8ebPK+A0OHqrRLlxClAgBYrrBQuuEGadIkaf36Vhmyc2pnXX7u5bpxwY0aNmiYDh05pH2H9snr8zZ4f2VVpUybqVlTZ8nhcLRKBgAAAAAA2jNKDeAk4pOSNO7cc1VTUSGft+FfKkmSDEM7WK0BANFn0yZp+nRp4ULpJNsVNodhGBrQe4Cun3e9Fl2ySOlp6crdl6ui4iIFvrUqJBAIqKCoQGOGjdGQ/kNa/LoAAAAAAIQDSg2gGYZNn67OvXqddLXGvuHDVZaeHqJUAIB25dVXpSFDpJ//XHKdfNuok7Gbdk0YOUHLFi3T3LPmKqCAsvKy5Kx0SpJKykuUnJisMyafIcMwWvx6AAAAAACEA0oNoBkSkpM1bs4cVZeXn3S1xpezZoUuGACgfamuln72M2noUOnvf2+VIRMTEjV7xmzduvhWTR0/VeXOcuXuy9XRkqOaPHayenbt2SqvAwAAAABAOKDUAJpp+IwZ6tyrl0oOHWryvgPDhulI794hSgUAaJf27ZOuukqaOVPaurVVhszonKEFFy7Q9fOv18A+A9WrWy/NOG1Gq4wNAAAAAEC4oNQAmimhQweNO+ccVZWVyefzNXnvlnPPVaDJOwAAUWHtWum006SlS6UjR1o8nGEYGtJ/iL6z4Du6Y8kdSumQ0vKMAAAAAACEEUoNIAjDZsxQ5549VXqS1Rol3bsrb/ToEKUCALRrfr/03HPS4MHSo49KHk+Lh3Q4HIqJiWmFcAAAAAAAhBdKDSAISSkpGjN7tipLS+U/yWqNbWefLa/dHqJkAIB2r7xc+sEPpJEjpX//2+o0AAAAAACEJUoNIEgjTj9dnbp3P+nZGq4OHbRr2rQQpQIAhI09e6S5c6Xzz5d277Y6DQAAAAAAYYVSAwhSUmpq/WoNn9fb5L07p09XdXJyiJIBAMLK++9Lo0ZJDz5odRIAAAAAAMIGpQZwCkbNmqUuffuqaN++Ju/zxcRo2+zZIUoFAAg7Xq/Uu7fVKQAAAAAACBuUGsApSOzYURMvuki1Lpdqa2qavDdv9Ggd4RdWAICGTJsmXXut1SkAAAAAAAgblBrAKRo+Y4Z6jxihI3l5J7130/nny28YbR8KABA+bDbpqack/v8BAAAAAIBmo9QATpEjJkaTL7lENptN1U5nk/eWde2q7AkTQpQMABAWli6Vxo2zOgUAAAAAAGGFUgNhqaioSP/85z/lPEmZ0Nb6jRmjwZMnqyg/X4FAoMl7t591lmoSEkKUDADQrqWlSb/4hdUpAAAAAAAIO5QaCLmKigo5nU65XC7V1NQ0+uHz+RodY+fOnbrssstUWFh40tez2+3q3bu3+vbtq759+yomJkZdu3at/zwtLU3z588/pbnYbDZNmjtXCR07qryoqMl7PfHx2n7WWaf0OgCACPPQQ1KnTlanAAAAAAAg7FBqIOTuvvtuZWRkKCMjQ127dm3wIykpSc8880yjY5imKUmKiYk54WuBQOC4VROxsbHasmWL8vLylJeXp8GDB+uvf/1r/ef/8z//o9jY2FOeT9f+/TVm9myVFRQ0WcRIUs748RwaDgDRbupU6eabrU4BAAAAAEBYotRAyD377LNyuVxyOp0qKytr8GPKlCmKi4s76VgDBw6U3W4/7sNms2nz5s3199hsJ/82t9vtLZrTaeefry59+6ooP7/pGw1DGy++WN4Wvh4AIEzFxUkvvlh3SDgAAAAAAAgaP1Ej5CoqKvT444+rpKSkyfu+WY3RlOzsbHm93uM+3G63xo8ff9w4p59+ukaOHKmRI0cqOztbS5curf/80UcfbfGcklJTNenii1XrcsntcjV5b0WnTtp+9tktfk0AQBh66CFpyBCrUwAAAAAAELYoNRBy1dXVuuuuu05aapyqmJiY41ZnBAIBrV27VpmZmcrMzNTAgQP1xz/+sf7zu+++u1Ved/iMGeo/dqwO5+ae9N6vJ09mGyoAiDbTp0t33WV1CgAAAAAAwhqlBkLum/MrJk2apM6dOzf4sXHjRnm93lZ5vZOdc9Fa7A6Hpl5+uWITEuQsLm76ZsPQhksukdfhCEk2AIDF4uPZdgoAAAAAgFbAxv6wTG5urlJSUhr82owZM+R2u+s/37Bhg6ZOnXrcllSmaWrgwIH1n/v9fi1ZskQvvPDCcWPV1NRo/Pjx9as3Dh06pMWLF9ef2eF0OnXxxRe3ypx6Dh2qkWecoS/eeUdJqalNnudRmZambWefrdPef79VXhsA0I794hfSoEFWpwAAAAAAIOxRaqBdevvtt487KPyb/y4rK1NSUlKDzyxZskTJycnHXSstLZUk5eTkyHFsVcTIkSP1+OOPa/bs2ZKk3/72t8rMzGyV3IZhaNLcucrdulVF+fnK6Nevyfv3TJqkXrt2KeNkB4wDAMLXjBnSHXdYnQIAAAAAgIjAHghol9LS0hQfHx/0c4ZhHPf5V199pWHDhtUXGqHQMT1d0+fNk6emRq6KiqZvNgxtvPhitqECgAgViI+XXniBbacAAAAAAGgl/ISNduuhhx7SNddc06Ix/vnPf+rcc8897logEFAgEKj/3Ov1NrlN1KkYNmOGhs+YocO5ufL7/U3e+802VACAyGM8/DDbTgEAAAAA0IooNRBy3xwU/s4776ioqEhHjx494WPPnj16/fXX68uHb/63c+fOiouLa/DjL3/5y3EFQlFRkV588UVde+21x72+1+tVbW2tJOnHP/6xnnrqKQ0dOrRV52iapqZfeaU69+qlomZsLbVn0iQd7tOnVTMAACx2+unS7bdbnQIAAAAAgIjCmRoIufj4eH3ve9/TXXfdpWXLljV6X//+/fW///u/kqTq6mpJ0tGjR5s8U6OysrL+88rKSt13330aPXr0cff98Y9/rC8xpk6dqsmTJ+vCCy9s0ZwakpqRoWlXXKH3/vAHuSoqFP9f530cxzC04ZJLdMH//Z8cHk+rZwEAhFYgIUHGiy+y7RQAAAAAAK2MUgOWeOKJJ/TEE080+/7p06cft2VUQ1566aXjPu/Xr59++MMfnnDfzJkz6//7oosuanaGUzFsxgzlffmlvvzkE/UeObLJba6qUlO1bfZsTVy+vE0zAQDanvHLX0oDBlgdAwAAAACAiMPbB4E2VL8NVc+eOpKXd9L7syZOVEH//m0fDADQdmbNkr73PatTAAAAAAAQkSg1gDaWmpGhafPmyet2q9rpbPpmw9D6yy9XdVNbVQEA2q1A167SK69IhmF1FAAAAAAAIhKlBhACw6ZP1/AZM3Rk797jDjNviDsxUevmzZOffdgBIKwETFPG3/8ude1qdRQAAAAAACIWvzUFQqB+G6pevZq1DVVR797advbZbR8MANBqjIcflr51bhMAAAAAAGh9lBpAiKRmZGj6/Pny1taefBsqSbunTdP+oUNDkAwA0FKBiy+W7rnH6hgAAAAAAEQ8Sg0ghILZhkqSNlxyiSrS0kKQDABwqnx9+sj40584RwMAAAAAgBCg1ABCyGazacaVV6pz7946nJt70vs9cXFaO3++vHZ7CNIBAILlj4mR+Y9/SCkpVkcBAAAAACAqUGoAIZbSpYtmXnWVFAjIefToSe8v69pVmy64IATJAABBe/JJadw4q1MAAAAAABA1KDUACwyZMkWnXXSRSgsK5Ha5Tnp/7rhxyuaXZgDQrngWLpTtppusjgEAAAAAQFSh1AAsYBiGpl52mQZPmqSCrCz5fb6TPrPpggtU0rVrCNIBAE7GM3SoHM89Z3UMAAAAAACiDqUGYJGYuDiddd116tKnjwqys096v99u16fz56s2NjYE6QAAjfElJsrx9ttSfLzVUQAAAAAAiDqUGoCFUrt21VnXXSdHbKxKCwpOen9lWpo+u/TStg8GAGiU7U9/kgYNsjoGAAAAAABRiVIDsFj/sWM15bLLVFFcLFdl5UnvPzh0qDJPPz0EyQAA/817990yrrjC6hgA2qHMzExNnDhRqampuueeexQIBE76zLPPPqtu3brJ4XBozpw5KmjGm1wAAACAaEepAbQDp11wgUbMnKnDOTnyeb0nvf/LWbO0d9SoECQDAHyj5pJLZP/Nb6yOAaAdcrvdmjt3riZMmKBNmzZp586deumll5p85tNPP9VPf/pT/eUvf9HevXtVU1OjH/zgB6EJDAAAAIQxSg2gHbA7HDpz8WL1GDpUh/bsOfk7+wxDGy+5RIV9+4YkHwBEu+px4xT3979LhmF1FADt0PLly1VeXq7HHntMAwYM0MMPP6znn3++yWe+/vpr/d///Z9mz56tnj176vrrr9emTZtClBgAAAAIX3arAwCok5yWprOvu07/+O1vVXzggDr36tXk/X7T1NoFC3TOCy8opagoRCkBIPpU9+ih+I8+kmJjrY4CoJ3avn27pkyZooSEBEnS6NGjtXPnziafufHGG4/7/Ouvv9bAgQMbvd/tdsvtdtd/7nQ6JUkej0cej+dUo7d738yNOYa/aJinFXP0+/2Kj4+X3bQpPj5efr+/Wa//zXPmsfdrBPuspKBfM1inOrfWEA3fr1J0zDMa5ihFxzyjYY5SdMyzNeZmBJqz2SuAkNm6YoVWPPecUrt3V2LHjie9P6G8XHOef14JFRUhSAcA0aUmOVnmpk1yDB5sdRQA7djdd9+tmpoaPf300/XX0tPTtWfPHqWmpp70+eLiYg0cOFB//etfdeGFFzZ4z/33368HHnjghOuvvPJKfZkCAAAAtHfV1dVauHChysvL1aFDh1Mag1IDaGf8fr9WPP+8Nr/3nnoMGyZHTMxJn0kpLNQ5L74oR21tCBICQHTwOByqee89Jc+ebXUUAO3cvffeK4/Ho8cee6z+Wq9evbRhwwb16NHjpM8vWLBAlZWVevfddxu9p6GVGr169VJBQYE6derUsgm0Yx6PRytWrNA555wjh8NhdZw2EQ1zlKJjnlbMcfv27Zo5c6Yuu+2n+sfTD2rNmjUaM2ZMs5/77qMvS5KeuntRs5/dunWrCgoK9NZnu/X6Ew80+7lgnercWkM0fL9K0THPaJijFB3zjIY5StExz+LiYnXr1q1FpQbbTwHtjM1m0+lXXaXigweV/9VX6jVihGy2po+/KevaVZ/On68zXn1VtmNLgQEAp85vGCp5/HFlUGgAaIa0tDRlZmYed62iokIxzXhzygsvvKA1a9Zo27ZtTd4XGxur2Aa2wXM4HBH7A++3RcM8o2GOUnTMM5RztNlscrlc8vr8crlcstlszXrtb57zHXuba7DPSgr6NYN1qnNrTdHw/SpFxzyjYY5SdMwzGuYoRfY8W2NeHBQOtEMJyck658Ybld67tw59/fXJDw6XVDBwoD6/6KIQpAOAyHfg9tuVceutVscAECYmTpyoDRs21H+el5cnt9uttLS0Jp/7/PPPdeedd+pvf/ubMjIy2jomAAAAEBEoNYB2Kr1XL81ZulSJqak6nJvbrGdyx43TVzNntnEyAIhs+y69VL1+9zurYwAIIzNnzlR5ebn+/Oc/S5IeeeQRzZ49W6Zpyul0NngY4uHDhzV37lzde++9mjBhgiorK1VZWRnq6AAAAEDYodQA2rHew4fr7CVLZNhsKj54sFnPfDVrlnJDtM8oAESaQ5Mnq8frr8swDKujAAgjdrtdzz77rG655RZlZGTojTfe0COPPCJJGj16dINnZbz66qs6cuSIfvKTnyg5Obn+AwAAAEDTKDWAdm7olCmaefXVclVUyHn0aLOe2Th3rgr692/jZAAQWY4MHKhOH34o086RYwCCd+mllyorK0vPPvusdu3apREjRkiq24rq0ksvPeH+O++8U4FA4IQPAAAAAE2j1ADCwLg5czT5kktUVlioaqfzpPcHTFNrr7xSJV27hiAdAIS/0owMJXz0kWI7dLA6CoAw1qNHD11yySVKT0+3OgoAAAAQsSg1gDBgs9k0fd48jZk9W0fy8lTrcp30GW9srD6+9lqKDQA4ieL0dAU++khJffpYHQUAAAAAAJwEpQYQJuwOh8669loNnTpVh/bskbeBAyf/W218PMUGADThaKdOqn3nHaWNHGl1FAAAAAAA0AyUGkAYiU1I0Dk33qg+o0bpwO7d8vt8J32GYgMAGlaUmqryv/1N3SZPtjoKAAAAAABoJkoNIMwkp6Xp3JtuUkbfvjq4Z0+zDpSk2ACA4x1JSdHh557TgNmzrY4CAAAAAACCQKkBhKHOPXvq3KVLlZyWpsKcnGY9Q7EBAHUOd+yo3Ecf1YjLLrM6CgAAAAAACBKlBhCmeg4dqtnXXy/TblfRvn3NeoZiA0C0O9yxo3bcf78mXnutDMOwOg4AAAAAAAgSpQYQxgZPmqRZ114rn8ejo/v3N+sZig0A0epwx47a9qMfafrNN8u0262OAwAAAAAATgGlBhDmRs+apbOXLJG3tpZiAwAa8U2hceYddyg2Pt7qOAAAAAAA4BRRagBhzjAMjT7rLIoNAGgEhQYAAAAAAJGDUgOIABQbANAwCg0AAAAAACILpQYQIVpSbKy87jod7tu3bQMCQIjt69RJ2+67j0IDAAAAAIAIQqkBRJBTLTY8cXH6ZPFi5Y0c2cYJASA0dvboocz/+R+defvtFBoAAAAAAEQQSg0gwpxqseE3Ta2//HLtmD69jRMCQNv6bNAg5f7whzp72TIKDQAAAAAAIgylBhCBTrXYkGFo++zZ+vzCC+U3jLYNCQCtzG8Yen/MGBV/73s6Z+lSCg0AAAAAACIQpQYQoU652JCUfdppWnPVVfI4HG2YEABaj8du15uTJ8t744065zvfodAAAAAAACBCUWoAEawlxcahwYO1cskSuRIT2zAhALScKyFBf50+XfELF1JoAAAAAAAQ4Sg1gAj37WLD5/WqMDdXgUCgWc+WdO+uD2+8UeWdOrVxSgA4NWUpKXpxxgylX3EFhQYAAAAAAFGAUgOIAt8UG+ffcoti4uJ08Ouv5ff7m/VsVWqqVtx4o4707t3GKQEgOAUZGXrp9NM1aMECzeEMDQAAAAAAogKlBhAlDMPQ0KlTdfEddyitWzft37lTXo+nWc/Wxsfr42uuUf7w4W2cEgCaJ6tPH/3tzDM1ackSnXXddYqJi7M6EgAAAAAACAFKDSDK9B4xQpfcdZd6DBmiAzt3qramplnP+e3/v707D4+yvvc+/pktmeyZyR5IIAlrQiJh3xdZpMoi1hWtVYuirTtVaW172uf0+NjreNCeWuWx6vF4qlerrdXqEW0LyCaCoEBCwh4CgRCyZ7JPZub5I5ISSTAhCUNm3q/ryhVyz9wz32+wX+v9md/9M2vr9dcrf/LkPq4QAC5s5/Dh+nD2bM1ZsUKTly6VyWTydkkAAAAAAOASIdQA/FBMcrKufeQRDZ04UacOHFCDw9G1Ew0GfTl/vj5dulROi6VviwSAr2mxWPT++PHaOWeOFj7wgLJmz5bBYPB2WQAAAAAA4BIye7sAAN4RHh2thfffr3WhocrZsEH2xESFdXFD8GNZWaqMj9e0t99WRFlZH1cKAFK13a63srNlHjNGi++5R4lDhni7JAAAAAAA4AWs1AD8WFBoqK665x5NuvZaVZ85o4ri4i6fWx0bq4/vvluFGRl9WCEASAXDh+ulyZMVNmOGljzyCIEGAAAAAAB+jJUagJ+zBARo5q23KtRm0+Y//lElBQWKHTy4S7d0aQkI0Nbrr1dpUpKy//Y3mdzuS1AxAH/hMhq1ffp0fWK3K33aNM373vcUEhHh7bIAAAD6Lbfboy9PVOr1PTWKu/nf9OFJi1o80sAH3tBjfy/T6MN7NCUtSrNHxMoeEuDtcgEA6BChBgAZjUaNu+YahURGav1//7dOHTyohKFDZTR2bTHXwYkTVT5ggKa9/bZCamr6uFoA/qA+LEwfzZ2rQyaTxl51lWbdeqsCg4K8XRYAAEC/1OJy673dp/TbDYd1tKxOkmQddIUaXK2Pm4IjdKTSqSOVRfrzF0UKMBk1LyNOK2akKmtgpPcKBwCgA9x+CoAkyWAwKH3aNC188EFFxMaqKC9PLU5nl88vHzhQH61YoeK0tD6sEoA/KE5J0e8XLtSRwEBNvfFGzb3jDgINAACAi7TvVLWW/HarVr69R0fL6hQaaNaMZKvKPnxOs+OcmpfQrFOvPqAnptp036w0jUwIV7PLrf/dW6zFz2/V8v/eqSOltd5uAwCANoQaANoZnJmpJY88ogHDh+tEXp4aHI4un9sUHKwNt96qvTNnyt2F21cBwLk8kvZOm6b/GTdOjcHBmr98uaZef71MZhaWAgAAdJfH49GrWwq05Pmt2neqRhFBFj2xYIS2/3iOHp5kU13OP2QP9CjcIjlLCzRxgFVPLBihtQ9N1wcPTNN12QNkNEj/yC/Rt57brGf/flBNLS5vtwUAALefAnC+uMGDtfSxx/TJ73+v3I0bFWqzyZaQ0KV9NmQwKHfWLJUPHKjJ77wja0ND3xcMoN9rDArSxm99S7vcbiWmpGjOHXcoaeRIb5cFAADQLzldbv34nRy9vatIkrQgI17/59oMxYZZu3T+qAERWn3TaH1/9hD96wd52niwVL9ed0hrc4t1X1Ygn5AFAHgV/x4C0KHQyEh96957Nee735XL6dSpgwflcnX9UznFQ4booxUrVDZwYB9WCcAXlA0YoD8uXaovDQaNmjlT1z3+OIEGAADARWpucev+N7/Q27uKZDRIP12YrhdvG9PlQONcQ2JD9dqd4/X8smxFhwboYEmtnlhXrq0lBnn6oHYAALqClRoAOmUymzV+4UJFJydr/euv68S+fUoYMkSBwcFdOr8+IkJ/v/NOZWzerIxNm2Ryu/u4YgD9ictoVO60aVqXkCCD2ayZ11+v8QsXymyxeLs0AACAfsnp8ui+3+/Suv1nFGA26sVbx2jOyLgevabBYNDCrERNTInSyrf3aNPBUr111KQYQ5IM5oBeqhwAgK5jpQaAb5SSlaVvP/64RkyZotNHj6q6tLTL53qMRuXOnKmP77lHFfHxfVglgP6kMi5O//ud7+h/o6IUnpCgxQ89pEnXXkugAQAA0ANrdlVr3f4zslqMevn2cT0ONM4VExao1+4Yr9uzQmWUR6VGm+KW/Upl9eyzAQC4tAg1AHRJZGysFj3wgKbfeKMaampUfPiw3N1YeVEVF6eP775be2fNksvI6AH8lctoVM7MmXp76VLl1tRo2IQJuu7xx5U2ZkzX9u0BAABAhyKmLtOGYw0yGQ168baxmjEsptffw2g0aPGwEH0/3S2zp0WBCUP12N/L9Pmxil5/LwAAOsOVRQBdZgkM1NQbbtDCBx5QmN2uE/v2ydnU1OXz21Zt3H03qzYAP1QZF6ePly/X35OTVVNdrSnf/rYWP/yw7AkJ3i4NAACgXysz2hQ5bZkk6ZfXjtLs4bF9+n5DIzy6wn1IzWcKVN3k1rLffaa3d57o0/cEAOAsQg0A3WIwGNp9svrkgQNyVHTvUzlV8fH6ePly7Z05k1UbgB9wG43KmTFD73/3u9pTXq6g0FBd/YMfaOayZQqwdn/DSgAAAPyTJTpZBaaBkqTrRoTolgnJl+R9rXLq9O9/qMkDrXK6PHrsT3v11If5crnZQhwA0Le4mgjgokQPHKgljzyiiYsXq6a0VGeOHZPH0/X/8+oxmZQ7a5Y+vvtuVcb13n1eAVxeKmNj9fHy5dqWna2igwc1aNQoXff440qfOpXbTQEAAPRQg9Ot6CWr5DaY1HDsS90yKuySvr/H2aSVkyP14JyhkqSXNh3VPa/vlKPReUnrAAD4F0INABctMDhYs2+/XQtWrFBAUJCO5+aqqb6+W69RFR+vj+6+WzkzZsjNqg3AZ7iNRuVOn6613/ue8urqVH3mjMZec42uXblScYMHe7s8AACAfs/j8WjNrmoFRCfL4mlW2fvPyGS89B8aMRoMenTeMP3mlmwFmo1at/+Mrn9xm05UdO+/DQEA6CqztwsA0L8ZjUZlzpql+LQ0bf7DH3Roxw5Zw8IUnZTU5U9he0wm5cyeraIRIzTpvfdkKynp46oB9KWq2FhtW7JERSEhKs3PV2xKiqbdcIOGTZwoI+ElAABAr/j0SLk2H2+Ux+3SUFehDtdXe7WeRVckKtkerLtf36kDJQ4t+e1WrbltrCak2L1aFwDA93BlAUCviElK0uKHH9b8u++WJTDwolZtVCYk6KO779ae2bPVYrH0UaUA+kqL2ay9s2bpw+99T3n19aoqKVH2VVfpxh//WCMmTybQAAAA6EVT0qJ039gIVW54RWGeOm+XI0m6IilSf71/mjIHRKiirlm3vvyZ3mIDcQBAL+PqAoBeY7ZYlD1/vm748Y81fNIklRQUqOzEiW7vtbFvxgx98IMfqDAjow+rBdCbjqen64P779f20aN1LD9fETExWnj//brqnnsUHh3t7fIAAAB8jsFg0Ly0YDl2/tXbpbQTH2HVWysm65rMBDldHj3+p736t//NYwNxAECv4fZTAHrd2VUbe9ev17a//EXHc3MVn5amwODgLr9GfUSEtl5/vQ6NHatxa9cqsrS0DysGcLGqo6O181vfUvGgQSopKJDb5dLo+fM17YYbCDMAAAD8VFCASb+5JVtDYkP163WH9LvNBTpSWqdf3zxaYVZW5QMAeoZQA0CfMFssGnPVVUoaOVKbvtprIzgiQlEDB3Z5rw1JOpOSorX33qthO3Yo85NPFNDU1IdVA+iq5sBA5c6cqQMTJqi2tlalubmKHTxYU2+4QcMnTeJWUwAAAH7OaDTokXnDNCQ2VD98e4/W7z+jb7/4qV6+fbySo7r+gTcAAL6OUANAn4pJTtaSRx7RnnXr9Nm776owN1cJ3Vy14TEadWDSJB3LzFTWhg1K++ILGbtxSysAvcdtMOhodrb2zp6t+qAglRw7JndLC6szAAAA0KFzNxA/WFKra19gA3EAQM/wMUoAfc5ssWjsggW64Uc/0vAJE1Ry9Gi399qQpKaQEH2+cKHW3nuvitPS+qhaAJ0pTk3V2hUrtGPRIlW43SrMzVV4VJSuuf9+LVixgkADAAAAHepwA/HP2UAcAHBxCDUAXDKxgwZpyaOPat7y5TJZLDqek6P6mppuv051bKw23HabNixbpmouogJ9rjo6Wp8sW6YN3/mOyu12nTp4UJXFxRo9b55ufPJJpU+dyu2mAAAAcEFtG4hnfbWB+J/36pcfsIE4AKD7uP0UgEvq7KqN5IwMffaXv2j/tm2qLC5WbEqKLAEB3Xqt4qFD9WFamobs2qVRGzcqqK6uj6oG/FNDSIhyZ87U4bFj5TYYVHHypBzl5RowfLgmLlmiYRMmEGYAAACgy4ICTHr+lmwNjQ3Vc/84pJe3FOjQmVr9583ZighmA3EAQNcQagDwipikJF1z//0aMWWKtv3lLyrKz1eo3a6oAQO6tZG4x2jUofHjdXT0aA3ZuVMjP/1UwbW1fVg54PvqQ0OVP2WKDo8bJ5fForrqapUWFio8OlpX3n67Rs+bJ2tIiLfLBAAAQD9kMBj08Nx/biC+8WCpFv92i353+zgNiwvzdnkAgH6AUAOA1xiNRg0dN07J6enas26ddn74oQpzchSdlKRQm61br+WyWHRg8mQdGj9eQ3btUvrWrQp2OPqocsA31YeFKW/q1NaVGWaznE1NOnPggAwGg7KuvFKTrr1W0QMHertMAAAA+ICFWYlKiQ7RPa/vUmF5vZb+dqv+48YrtGBUgrdLAwBc5gg1AHhdYHCwJixapCHjxmn7e+8pf+tWVRQXK27wYAUGB3frtdxmsw5OnKjDY8cq9csvlbF1q0Kqq/uocsA31IWHK2/aNB3JzpbbbJbb5VJZYaEaHA4ljRypyUuXKjU7u1urqAAAAIBvkpEYofcfmKb73/xCnx4p172//0IPXDlEj8wd5u3SAACXMUINAJcNe0KCFqxYoZFTp2rHX/+qgj17ZA4IUMygQTJbund/VbfZrMPjx+vImDFK3b1bGVu2KLSqqm8KB/qp2ogI7Zs+XQWjR8ttMsnj8ai6pERVp08rOilJM2+5RRkzZijAavV2qQAAAPBR9pAAvX7XBP3ftfv1ypYC/Wb9YeWdqtEdI/hADQCgY4QaAC4rBoNBgzMzNXDECB347DPteP99FeXnK8xuly0xsdubEntMJh0ZO1ZHs7OVsmePMjZvVlhlZR9VD/QPDptN+6ZNU8EVV8hjMkmS6qqqVHb8uELsdk276SZlz5+vMLvdy5UCAADAH5hNRv10YbpGDQjXqj/naN3+M8o/aZI5ilufAgDOR6gB4LJktliUMX26UrOztXf9eu1au1bHc3JkS0hQeExMt2+D4zEadTQ7WwVXXKHBOTnK2LxZ4eXlfVQ9cHmqsdu1b/p0HcvKkuergLCxrk6lhYUyBwQo88orNXHxYsUkJ3u5UgAAAPijpdkDNTQ2TPe8vlOnqhuV8J3VqjSc9nZZAIDLDKEGgMtaUGioJi5erGETJ+qLtWu1b8sWFebkKDIuThGxsRcVbhRccYUKsrKUvG+fhu3YodgTJ/qoeuDyUJqUpIPjx+t4RkZbmNFQW6uyEydkNBqVOnq0xi1cqMGZmeybAQAAAK8aNSBCf31gmr77/zZpX6l0UKmKmHKzPB6Pt0sDAFwmCDUA9Au2uDjNueMOXTF3rnI2bFDupk0q3LtXEXFxioyL6/6FWINBx0eN0vFRoxRZUqKhn3+uwTk5sjQ3900DwCXmtFh0LDNTh8aPV1V8fNvxBodDpSdOyGQyKTU7W2OuukqDs7Jk+uo2VAAAAIC3RYcG6l9m2rVg1UsKH7dYkdNv08tf1mjsWG9XBgC4HBBqAOhXogcO1OzvfEdZc+a0hhuffNIabsTGKiIurtt7bkhSVVycPl+4UF/Om6fUPXs0ZOdORZaW9kH1QN+rjo7WoXHjdHT0aLUEBrYdr6+pUdmJEzJbLBo6bpyy58/XoMxMwgwAAABclsxGgyrXvaQrRo/WEXeMpiZFebskAMBlglADQL8UlZioWbfeqivmzNHeDRuUs2GDjufmKjwmRpEXGW60BAbq4IQJOjhhgmKPHdPQzz/XwP37ZXK7+6ADoPe4jUYVjRihg+PG6UxKSrvH6qqrVX7ihCyBgRo2cWJrmDFq1EX9bwQAAAC41GLdFdq0ZpXSb9vg7VIAAJcJQg0A/ZotPl4zb7lFWVdeqdxPPtHeDRt0PCenNdyIj7/oC7dnBg/WmcGDZXU4NOSLLzRk1y4FOxy9XD3QM/VhYTo8ZoyOjB2rhrCwdo/VVVWpvKhIFqtVI6ZOVfa8eUpKTyfMAAAAQL/jbqjxdgkAgMsIoQYAn2CLi9P0m25S1pVXKueTT7R3/Xodz8lRWHS0bAkJF30htzEsTLkzZ2rf9OkacOCAhn3+ueIKCsRWyvCm0ykpOjRunIpGjGjb+FuSPB5P68qMoiIFBgUpfdo0jZ4/X0kjR7IBOAAAAAAA8AmEGgB8SkRMjKbdcIOyZs9W7qZN2vOPf+h4bq6soaGyJyYqwGq9qNf1GI0qGjlSRSNHKqSyUsn79mnQvn2ynz7dyx0AHauIj9fx9HQVjhqlOput3WNul0vVpaWqKS2VNSREmTNnavS8eRowfDhhBgAAAAAA8CmEGgB8Unh0tKZcd50yZ83Swe3blfPJJzpTUCC32y1bQoJCbbaLvthbZ7Mpf9o05U+bprDy8raAI/LMmV7uAv6uKiZGxzMyVDhqlBxR52+M2NTQoIpTp9RcX6/wmBhNWLxYIyZPVuLQoYQZAAAAAADAJxFqAPBpYXa7xn7rW8qaM0eFOTnK27JFBbt3q7yoSKE2myLj42W2WC769R1RUdo3Y4b2zZih8NJSDcrNVXJeniLKynqxC/iT6qgoHc/I0PGMDFXHxp73uMfjkaO8XFUlJTKaTIpPTVXmrFkaMm6cwux2L1QMAAAAAABw6RBqAPALloAADRk7VmljxqisqEiHduxQ7qZNOnXggExms2yJiQoOD+/Re9TExChn9mzlzJ6tyJISJefmatC+fQqrrOylLuCrHDZb64qMjAxVxcd3+Bxnc7Mqi4tVX1WlULtdmbNmaeTUqUrOyOhRMAcAAAAAANCfEGoA8CsGg0ExSUmKSUrSmAULdPTLL5W7aZOK8vNVWlio8OhoRcTGymgy9eh9quLiVBUXp71z5sh26pQG7dunpPx8Ag60qY2M1PGRI3V81ChVJCZ2+ByPx6P66mpVnj4tj9utqAEDNGnJEg2dMEFRnZwDAAAAAADgywg1APgta0iI0qdN04gpU1R8+LAOfPaZ9m/bphN5eQoICpItIUHWkJAev09lYqIqExO1e948hVZUKP7oUcUfPaq4ggIFNjb2QifoD5qsVpWkpOh0aqpOp6aq9gK3impxOlV95oxqy8tlDQtT2pgxypg+XSmjRyswKOgSVg0AAAAAAHB5IdQA4PeMRqMGDBumAcOGacKiRTq0c6dyN27UmYICNTU0KDgiQhExMQoMDu7xe9Xa7Tpst+vwuHGSxyP7qVNtIUfMiRMyuVy90BEuBy6TSWVJSSpOTVVJaqrKExOlC2ze7WppUU1ZmRzl5ZKkiNhYTb7+eg2fOFHxqals/A0AAAAAACBCDQBoJ9RmU/a8ecqaPVvFR46oMCdHB7ZvV3lRkZobGxUSGamImBgF9Man5Q0GVQwYoIoBA5Q3fbpMTqdiCwvbQo7IkhJxGbv/8Kj1tmNnV2KcGTRIrm/Y68LlcslRVqaa8nLJ7VZ4dLSumDtXqaNHKyk9XcFhYZemeAAAAAAAgH6CUAMAOmAymzVw+HANHD5cE5cs0alDh1SYk6ODO3ao9PhxtTQ3KyQyUuExMQqwWnvlPV0Wi4qHDFHxkCGSpMC6uraAI+rkSYWXlcno8fTKe6Hn3AaDaqKjVT5ggE6npqokJUWNoaHffJ7LJUd5uWrKyuRxuxUWFaWsWbOUmp2tpPR0hUREXILqAQAAAAAA+idCDQD4BmaLRcnp6UpOT9ekpUt16uDBtoDjzLFjcjmdCrHZFBETI0tgYK+9b1NIiAozM1WYmSlJMjU3y3b6tOzFxW1f4aWlBB2XwNkAoyIxURUJCapISFBlfLxcAQFdO9/tbg0ySkvldrsVZrcrY/p0pY4Zo+SMDIVGRvZtAwAAAAAAAD6CUAMAusESEKBBo0Zp0KhRmnzddSo6cEDH9u7Voc8/V0lBgVwtLQqJjFSozabA4OBe3QfBFRCgsuRklSUntx0zOZ1tQYetuFj2U6cUQdDRI26DQTUxMW3hRUViYmuA8Q23kvq6luZm1VZVqba8XC6XS6E2m0ZMmaK0r4KM8KioPuoAAAAAAADAdxFqAMBFsgQGKiUrSylZWZry7W+raP9+Hdu7V0e//FKVxcVqbmiQyWxWiM2mUJutV1dxnOWyWFSWlKSypKS2YyanU5ElJbKfOiVbSYlCKysVWlmp4Opqwo5zuA0G1YeHq9ZmU63Npqr4+H+uwOhmgCG13laqrrpadZWVaqqvl9FkUqjNpmETJ7YFGRExMX3QCQAAAAAAgP8g1ACAXhAYFKS07GylZWdr5rJlKj1+XKePHNGJ/HwV7d/fuorD6VRAUJBCbTYFR0bKZDL1SS0ui0XlAweqfODAdscNbrdCqqraQo5z/xxaWanAxsY+qcebmqxW1dpsqrPZVBsZ2RZg1NpsqouIkKcHfwcej0eNtbWqraxUQ02NJCk4IkJxqalKycpSfFqa4lNTFRwe3lvtAAAAAAAA+D1CDQDoZWaLRQlpaUpIS1P2/PlqrKvT6aNHdfroUR3bu1elhYWqPH1aHo9HQWFhCrXZFBQW1qu3quqIx2hUrd2uWru9w8ctjY3tQo4gh0MBjY2tXw0N7b6bnc4+rfVCWiwWNVutag4Kav1+zp8bwsLaBRfOXtrE/azmxkbVVlaqrrJSbpdL1pAQRcTGKnPWLCUOHar4tDRFxMT0+d8lAAAAAACAvyLUAIA+Zg0J0eDMTA3OzNTExYvlKC/X6aNHVXz4sAr27FFVSYlKCwtlMBplDQ1VUFiYgkJDZe7iJtS9xWm1qjIhQZUJCd/4XKPLJUsHYcfZ7yanUwaPRwa3W8avvsvjaTvmMRolg0Eeg0Eeo1Hur77LYDg/tAgKkvOc8MLdRytcvs7tdquxtlYNDocaa2vlbGpSgNWqULtdmbNmacCIEUpIS1PUwIF9tuoGAAAAAAAA7RFqAMAlZDAYFB4drfDoaA2bMEHTb75Z5SdPquSrkOPUoUOqKStT9ZkzcrW0yGAwtAYdX4Udlzro6IzbZFJTSIiaQkK8XUqvcLtcaqyrU4PDoQaHQy6nszVkCglRcHi4kjMyWldipKYqLiVFAb28AgQAAAAAAABdQ6gBAF5kNBoVk5SkmKQkjZo5Ux6PR7WVlaosLlb5qVMqO3FCpw4eVE15uapLS/8ZdISEyBoWpqCwMFkuk6Cjv3C7XGqorW1bhXHu7zQkIkKDMjMVN3iw7ImJsickKDIuTiYz/7oEAAAAAAC4HHCVBgAuIwaDQWF2u8LsdiVnZEhq3ZC6rqpKFadOqaK4WKXHj6v48GFVl5aqprRULqdTMhhkCQiQxWpVQFCQAr767q8X491ut5yNjWpubFRzQ4OaGxvV0tgot8fzzwAjMlKDMjMVn5IiW0KC7ImJioyN9dvfGQAAAAAAQH/AlRsAuMwZDAaF2mwKtdnODzqKi1Vx6pSqS0tVefq0Kk6dUkNNjWrKytTc2Ci3yyVD64u0CzssVqssgYEyGo1e7e1ieTwetTidam5oaBdeuFpaJEkGqTXgsVoVGBysuJQURSUmKjw6WraEBNkSEggwAAAAAAAA+iGu5gBAP9Qu6EhPbzvu8XjU3NCg2srKdl81paUqP3VK1WfOqLGuTo6vQg+DwdB6nlpvhWUym2U0m2W2WGQ0m2U698tiaX3cZGo7rze4XS65Wlr++eV0ytXSIndLi1q++u5yOuVyuVp7/6pPk8XSFtREJSa2hhXx8W2/l5CvvgeHh/fb8AYAAAAAAADtEWoAgA8xGAwKDA5WYHCwogYMOO9xl8ulhpqadoFHU329mhsa1FBbq4aamtb9JhwONdbXy9XSImdTk1xOZ7uQwWAwSBcKNjyec4u64PMM54Qp5wYo1uDg1k3Sv9o7JCgsTIHBwQqwWhUSGfnP4CIyUpbAwB781gAAAAAAANBfEGoAgB8xmUxtKxm+idvtlrOpqW1PirO3emo655ZPbpdLHo9HHrdbHo9H8njkPufPBqNRBoOh9evsn7/6bgkMPG8PkHO/c2soAAAAAAAAfB1XjAAAHTIajQoMClJgUJC3SwEAAAAAAAAkSdxkHAAAAAAAAAAA9AuEGgAAAAAAAAAAoF8g1AAAAAAAAAAAAP0CoQYAAAAA9FBubq7Gjx8vm82mxx57TB6P5xvP2bhxo0aOHKno6GitXr36ElQJAAAA9H+EGgAAAADQA01NTVq0aJHGjh2rnTt3Ki8vT6+99toFzyktLdXixYt1yy23aNu2bXrjjTe0YcOGS1MwAAAA0I+ZvV0AAAAAAPRna9euVXV1tVavXq3g4GA99dRT+sEPfqA777yz03PeeOMNJSQk6Kc//akMBoN+9rOf6ZVXXtHs2bM7fH5TU5Oamprafq6urpYkVVRU9G4zlxmn06n6+nqVl5fLYrF4u5w+4Q89Sv7Rpzd6rKmpkdVqVWXxcVmtVu3atUs1NTUyGo1yu91t3yW1O3bgwAFZrVYVH82XpLZza2trO3z+ud8PHTqk0NBQVZ0+3qXzLvRaF3r+2RrP9lZTU6Py8vJL8nv1h39eJf/o0x96lPyjT3/oUfKPPs/+/9eurGzujMHTk7MBAAAAwM/94he/0Pbt2/Xhhx9Kav0PtKioqAsGDnfeeaeCgoL0wgsvSJKKi4s1Z84c5eXldfj8n//85/rFL37R+8UDAAAAXnDkyBGlpqZe1Lms1AAAAACAHqipqVFKSkrbzwaDQSaTSZWVlbLZbJ2ek56e3vZzeHi4Tp482el7/OhHP9Kjjz7a9nNVVZUGDRqk48ePKyIiohe6uDzV1NQoKSlJJ06cUHh4uLfL6RP+0KPkH336Q4+Sf/TpDz1K/tGnP/Qo+Uef/tCj5B99VldXKzk5WXa7/aJfg1ADAAAAAHrAbDYrMDCw3TGr1ar6+vpOQ42vn3P2+Z0JDAw87z0kKSIiwmf/g/dc4eHhPt+nP/Qo+Uef/tCj5B99+kOPkn/06Q89Sv7Rpz/0KPlHn0bjxW/3zUbhAAAAANADdrtdpaWl7Y45HA4FBAR0+Zxvej4AAACAVoQaAAAAANAD48eP12effdb287Fjx9TU1HTBJfVfP2f37t0aMGBAn9YJAAAA+AJCDQAAAADogRkzZqi6ulqvv/66JOnpp5/W3LlzZTKZVFNTI6fTed45ixcv1pYtW7Rhwwa1tLTomWee0VVXXdXl9wwMDNS//Mu/dHhLKl/iD336Q4+Sf/TpDz1K/tGnP/Qo+Uef/tCj5B99+kOPkn/02Rs9Gjwej6cXawIAAAAAv/Puu+9q2bJlCgsLk8vl0saNG5WRkaHBgwfrueee07XXXnveOS+88IIefvhhRUREKCQkRNu3b1dcXNylLx4AAADoRwg1AAAAAKAXnDx5Ujt37tSUKVMUExPTpXMOHz6s/Px8zZw50+c3gwQAAAB6A6EGAAAAAAAAAADoF9hTAwAAAAAAAAAA9AuEGgAAAAAAAAAAoF8g1AAAAAAAXHbee+89paamymw2a+LEicrPz/d2SX1qwYIFeu2117xdRp9atWqVFi1a5O0y+sT//M//KDk5WaGhoZo7d66OHTvm7ZLQDeXl5UpJSWn39+aLM6ijPs/lC3PoQj360gzqqE/mUP/T2ZzxpfnTlV4uZvYQagAAAABAP5Kbm6vx48fLZrPpscceky9uk3jkyBHdeeedevrpp3Xy5EkNGjRIy5cv93ZZfeaNN97Qxx9/7O0y+lRubq5eeOEFPffcc94updcdOXJETz75pN59913l5eVp0KBBuuOOO7xdVq/p6OKpL82hsrIyLVy4sF1/vjiDOurzXL4why7Uoy/NoM7+mfWlOdTZhXBfmj2dzRlfmj9d6eViZw+hBgAAAAD0E01NTVq0aJHGjh2rnTt3Ki8vr99/qrYj+fn5euqpp3TjjTcqLi5O9913n3bu3OntsvpERUWFVq5cqeHDh3u7lD7j8Xi0YsUKPfzww0pLS/N2Ob3uyy+/1KRJkzRmzBglJyfrzjvv1MGDB71dVq/o6OKpr82hm2++WTfffHO7Y744gzrq8yxfmUOd9ehrM6ijPn1pDnV2IdzXZk9nc8aX5s839dKT2UOoAQAAAAD9xNq1a1VdXa3Vq1crLS1NTz31lF555RVvl9XrFi5cqHvvvbft5wMHDmjIkCFerKjvrFy5UkuXLtWkSZO8XUqf+d3vfqfdu3crJSVFH3zwgZxOp7dL6lXp6elav369vvzyS1VXV+u3v/2t5s2b5+2yekVHF099bQ699NJLeuihh9od88UZ1FGfZ/nKHOqsR1+bQR316UtzqLML4b42ezqbM740f76pl57MHkINAAAAAOgn9uzZo0mTJik4OFiSlJWVpby8PC9X1beam5v1zDPP6Pvf/763S+l1GzZs0Lp16/SrX/3K26X0mdraWv3kJz/R0KFDVVRUpNWrV2vGjBlqbGz0dmm9Jj09Xddff73GjBmjyMhIbd++Xc8884y3y+oVHV089bU5lJqaesHHfWUGddanL82hjnr0xRnUUZ++NIc6uxDua7PnXJ3NGV+ZP9L5vfR09hBqAAAAAEA/UVNTo5SUlLafDQaDTCaTKisrvVhV3/rJT36i0NBQ3XPPPd4upVc1NjZqxYoVevHFFxUeHu7tcvrMO++8o7q6Oq1fv14//elP9be//U1VVVV6/fXXvV1ar/nss8/0/vvva/v27XI4HLrlllt09dVX9+t7vZ/V0cVTf5tDvjqDJP+YQ/4wgyTfnUPnXgj35dnT2Zzxpflzbi+9MXsINQAAAACgnzCbzQoMDGx3zGq1qr6+3ksV9a2///3vWrNmjd58801ZLBZvl9Or/vVf/1Xjx4/XNddc4+1S+lRRUZEmTpwou90uqfWf4aysLBUUFHi5st7zxz/+UTfffLMmTJig0NBQ/fKXv9TRo0e1Z88eb5fWJ/xpDvnyDJL8Yw75wwySfHcOnXsh3FdnT2dzxpfmz9d76Y3ZY+7F+gAAAAAAfchutys3N7fdMYfDoYCAAC9V1HeOHj2qW2+9VS+++KLS09O9XU6ve/PNN1VaWqrIyEhJUn19vd566y3t2LFDL7zwgneL60VJSUlqaGhod6ywsFCzZ8/2UkW9r6Wlpd0nhR0Oh+rq6uRyubxYVd/xlznk6zNI8o855A8zSPLNOXT2Qvhnn30mi8Xik7OnsznjS/Ono156Y/YQagAAAABAPzF+/Hi9/PLLbT8fO3ZMTU1NbZ9A9RUNDQ1auHChrr32Wi1ZskS1tbWSpJCQEBkMBi9X1zs2b96slpaWtp9/+MMfatKkSbrjjju8V1QfuOaaa/TAAw9ozZo1Wrhwod555x3t3r1bCxYs8HZpvWbq1Km666679OyzzyouLk4vv/yy4uLilJWV5e3S+oQ/zCF/mEGSf8whf5hBku/NoY4uhPva7OlszphMJp+ZP531uGnTpnaB28XMHkINAAAAAOgnZsyYoerqar3++uu6/fbb9fTTT2vu3LkymUzeLq1Xffzxx8rPz1d+fr5+97vftR0vKCjQ4MGDvVdYLxo4cGC7n0NDQxUdHa3o6GgvVdQ37Ha7PvroI61cuVKPPvqo4uPj9Yc//MFn/h4l6aabbtKBAwf03HPPqbi4WKNGjdI777zT728X0hl/mEP+MIMk/5hD/jCDJN+aQ51dCJ8+fbpPzZ7O5syzzz7rM/Onq7P0YmaPwdPfd4wBAAAAAD/y7rvvatmyZQoLC5PL5dLGjRuVkZHh7bIA+DCDwdDuIhRzCEBfeffdd7V06dLzjhcUFGj37t3MHkgi1AAAAACAfufkyZPauXOnpkyZopiYGG+XA8APMYcAeAOzBxKhBgAAAAAAAAAA6CeM3i4AAAAAAAAAAACgKwg1AAAAAAAAAABAv0CoAQAAAAAAAAAA+gVCDQAAAAAAAPRYfX293G73RZ3b0tLS4eutW7dOTU1NPS3tPLfccos2b94sSWpsbFRjY6N6a9vZpqYm/epXv+qV1+qOEydO6NVXX73k7wsAlxqhBgAAAAAAAHrE5XIpNjZWMTExCg0NVXR0tKKjo2W325Went7uub/85S+1aNGitp/feustLViw4Lxgw+FwaO7cuaqpqbnoumbPnq3f/OY35x0fNmyYbrvtNlVVVenBBx9UbGxsW81nvwwGg/bv39/t97z33ns7DGnOOnHihAwGg+rr67v92ucqLCyUwWCQw+GQJNntdr3wwgtat25dj14XAC53hBoAAAAAAADoEZPJpNraWpWXl2vatGm66667VFZWpoqKCuXl5Sk/P19paWmSpMDAQEVERLSde8011+jMmTN69NFH272mxWKR1Hqx/uu2bdt2XgiRn59/3vPMZrPMZvN5x5944gmNGDFC5eXleumll1RTU6Py8nKVlZW1fYWEhLTV0FXr1q1TUVGRnnzyyU6fY7Va2/XXkYceeqhdb3Pnzu2wt3O/h4SE6A9/+IMeeughOZ3ObtUNAP0JoQYAAAAAAAB6xfr16/X555/r9ttv19tvv61FixbJ4/HIbDarublZkmQwGNoFDSEhIXrjjTdUVlamuro61dbWqrGxUU6nU2azWU6nU42Njaqrq2u3usFqtbYFEI2NjXK73aqvr1dLS0vbraQsFouMRqMaGhrk8Xh07NgxDR48WJL08ccftwUtnTGZTN3q/+c//7meeeaZCz7nbJhhMBg6fU5jY6PuvfdelZWVac2aNaqrq1NjY6Oamprkcrnk8XjahSINDQ2SpCFDhmjevHl64403ulU3APQnhBoAAAAAAADosa1bt+rWW2/VH//4R40aNUpXXnmlduzYod/85jcyGAwXDAgyMzP15ptvas2aNYqKilJUVJRSUlLkcrnafo6KitLy5csldbzK4dNPP1VMTIyio6Pbnv+Pf/xDjz76qGJiYnT8+HFZrVYVFhbKarUqPz9fQ4YMOe/r7F4b3VVSUiKHw6ErrrjivMd2796tt95667zjNTU1evnll887/vX+zGazvv/977et3IiKitKIESMkSYmJiVq6dGnbc2+99Vb9+c9/vqgeAKA/INQAAAAAAABAj7jdbl199dWqqqrS3XffLbvdrhEjRigqKkqrVq1ScXFxh+e1tLS0rbKQpJUrV6qpqUl1dXV6++23lZ2drbq6uraVCm+++aakjlc5zJ07V3V1daqqqlJFRYXKy8s1f/58/frXv1Ztba0GDRrUtkLEaDTK4/GopaVFhw8fbvuKjo6+4H4YF5KTk6Nx48Z1+Nirr76qV1555bzjtbW1evDBB88LUr7en9Fo1KuvviqHw6HKykpVVFTo4MGDkqTS0lJ99NFHbc8dO3as8vLyLqoHAOgPCDUAAAAAAADQI0ajUevWrdO+ffv0yiuvyO12q7S0VHl5efr000+VkJDQ4Xlr165VbGysgoODtWrVqnaPbd68udOQwGQyqbi4uG3lQl1dnQwGgyoqKrRt27Yu19yRC90W6kJKS0sVGxt73nGPx6O//OUv+u53v3veY4mJiXrooYf0ox/9qN1xk8mk1atXKzo6WnfddVdbTbt27dLp06cvWIfBYGgLiQDAFxFqAAAAAAAAoMeCgoJUW1ur0tJSud1u5ebmKicnR9HR0Z2es2jRItXU1Gj58uVtG2hLUl1dnV555RXdeOONuummm3T06NF257ndbiUkJLTb1FtqXS1x9dVXn/f8zpw8ebLdrad2797d/ca/EhoaKofDcd7xdevWqaampt0tos71xBNPaN++ffrb3/7WdsztduvRRx9VWVmZXn311bbja9as0fe+971vrOXsniIA4IsINQAAAAAAANBj//7v/67HH39czz//vBoaGrRq1So9/PDD+vOf/yyPx9OtC+0rV67UuHHjNGfOHI0cOVIzZ87U4cOH2x53uVznnePxeDRz5kzddddd+tOf/tSl9xkwYEC720+NHj26yzV+3aBBgzoMU1544QUtW7ZMQUFBHZ4XGRmpu+66S08//XTbsa/3d/Z39+yzz6q0tFT79u3rtI4zZ84oKirqYloAgH7B7O0CAAAAAAAA0P+99tprkqSdO3dq7ty5+uCDD9oey8nJUWNj4ze+hsfj0c9+9jN98MEH+uKLLyRJP//5z+VwODRr1ixt2rRJqampcrlcbbefklpXdpwNAv7jP/6jS/V2FIycreFiZGZm6sCBA6qtrVVoaKgkac+ePXr33XfbeunMfffdp2nTpqmiokJ2u10ul0urV6/WmjVr1NzcrKysLEmtq0F27NghSSorK+vwtd5//31dffXVF9UDAPQHrNQAAAAAAABAr6ivr1dRUZFaWlr0X//1X1q1apWuu+46JScnq6SkpMNznE6nDh06pC1btmjjxo167733tGXLlnb7UzzzzDOaPn26NmzYIKl1g/Gv336qubm5W7UaDAaZzeZ2t58qKytr20y8uwwGg26//fZ2ocrw4cP1wQcffOMKkCFDhuj48eOy2+2SWvs79/ZTXe2tublZv/71r3XnnXdeVA8A0B+wUgMAAAAAAAA9cujQIY0ePVr19fWKiIhQZmamNm/erGHDhum2225TRESEqqurtW3bNq1fv14pKSmSpNOnT+vGG2/UyJEjNXToUK1YsaJtDw2n06mwsDCZzWa5XC499dRTKisrk8PhkNlsbrf5eF5eXoebkTscjnYbf9fX10tqDQ3S09Pb3dLqXFVVVWpqalJwcHC3fg+PPfaYxo8fr2uuuUbjxo2T1Wo9b9WE0+mUdP6G5AEBAW1/joiIUEREhCTp6quv1tSpUzvs7euv8+STT2rRokVKTU3tVt0A0J8YPOwcBAAAAAAAgB7605/+pHHjxmnw4MEdPl5XV6fk5GQNGzZMq1ev1uTJk3XkyBE9//zzWr16tQwGgwoKCrRmzRpt3bpVR44cUXl5eVsIIEkhISGqrKyUxWK5YC05OTmaPn26XC6XNm3apOzsbEmt4UdGRoYcDkfbLaK+7q9//atuuOEGzZ8/X++//363fw+5ublauXKlPv744/Me+/GPf6y33npLRqNRBw8e7PZrn7Vq1Sr953/+p8aMGaMtW7ZIkvbv368HH3xQH3744UWvNgGA/oBQAwAAAAAAAJeEx+M5b4XCN3E6nXK5XDIajbJYLF0+PycnR8OGDVNgYGC33q+pqUl1dXVtt4K6GC6XSyaT6bzjX3zxhQ4cOKC5c+cqJibmol+/vLxcNTU1bStevul9AcCXEGoAAAAAAAAAAIB+gY3CAQAAAAAAAABAv0CoAQAAAAAAAAAA+gVCDQAAAAAAAAAA0C8QagAAAAAAAAAAgH6BUAMAAAAAAAAAAPQLhBoAAAAAAAAAAKBfINQAAAAAAAAAAAD9AqEGAAAAAAAAAADoFwg1AAAAAAAAAABAv/D/AebQBkA2UdWWAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1600x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class ParkingVisualizer:\n",
    "    def __init__(self, scheduler):\n",
    "        \"\"\"\n",
    "        修正版可视化工具初始化\n",
    "        \"\"\"\n",
    "        self._scheduler = scheduler\n",
    "        \n",
    "        # 设置中文字体\n",
    "        plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统\n",
    "        plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题\n",
    "        \n",
    "        self.color_palette = plt.cm.tab20.colors\n",
    "        self.color_index = 0\n",
    "        \n",
    "    @property\n",
    "    def scheduler(self):\n",
    "        \"\"\"提供对scheduler的安全访问\"\"\"\n",
    "        return self._scheduler\n",
    "        \n",
    "    def _get_next_color(self):\n",
    "        \"\"\"获取下一个颜色\"\"\"\n",
    "        color = self.color_palette[self.color_index % len(self.color_palette)]\n",
    "        self.color_index += 1\n",
    "        return color\n",
    "    \n",
    "    def plot_combined_dashboard(self):\n",
    "        \"\"\"\n",
    "        绘制综合仪表盘：甘特图、平面图和统计图\n",
    "        \"\"\"\n",
    "        plt.figure(figsize=(16, 12))\n",
    "        plt.suptitle('停车场调度系统 - 综合仪表盘', fontsize=16)\n",
    "\n",
    "        # 甘特图\n",
    "        plt.subplot(2, 2, 1)\n",
    "        self._plot_gantt_chart(ax=plt.gca())\n",
    "\n",
    "        # 平面图\n",
    "        plt.subplot(2, 2, 2)\n",
    "        self._plot_parking_layout(ax=plt.gca())\n",
    "\n",
    "        # 占用率统计\n",
    "        plt.subplot(2, 2, 3)\n",
    "        self._plot_utilization(ax=plt.gca())\n",
    "\n",
    "        # 时间分布\n",
    "        plt.subplot(2, 2, 4)\n",
    "        self._plot_time_distribution(ax=plt.gca())\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "    \n",
    "    def _plot_gantt_chart(self, ax=None):\n",
    "        \"\"\"修正后的甘特图绘制方法\"\"\"\n",
    "        if ax is None:\n",
    "            fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "        assignments = self._scheduler.get_assignments()  # 改为self._scheduler\n",
    "        if not assignments:\n",
    "            print(\"无分配数据可绘制\")\n",
    "            return\n",
    "\n",
    "        # 准备数据\n",
    "        spots = sorted({info['spot_id'] for info in assignments.values()})\n",
    "        car_assignments = []\n",
    "\n",
    "        for car_id, info in assignments.items():\n",
    "            start = self._time_to_minutes(info['arrival_time'])\n",
    "            end = self._time_to_minutes(info['leave_time'])\n",
    "            car_assignments.append({\n",
    "                'car_id': car_id,\n",
    "                'spot': info['spot_id'],\n",
    "                'start': start,\n",
    "                'end': end,\n",
    "                'duration': end - start\n",
    "            })\n",
    "\n",
    "        # 为每个车位创建水平条\n",
    "        for i, spot in enumerate(spots):\n",
    "            spot_assignments = [a for a in car_assignments if a['spot'] == spot]\n",
    "            for assign in spot_assignments:\n",
    "                color = self._get_next_color()\n",
    "                ax.barh(\n",
    "                    y=spot,\n",
    "                    width=assign['duration'],\n",
    "                    left=assign['start'],\n",
    "                    height=0.5,\n",
    "                    color=color,\n",
    "                    edgecolor='black',\n",
    "                    label=assign['car_id']\n",
    "                )\n",
    "                # 添加车辆ID标签\n",
    "                ax.text(\n",
    "                    assign['start'] + assign['duration']/2,\n",
    "                    spot,\n",
    "                    assign['car_id'],\n",
    "                    ha='center',\n",
    "                    va='center',\n",
    "                    color='white',\n",
    "                    fontweight='bold'\n",
    "                )\n",
    "\n",
    "        # 设置y轴\n",
    "        ax.set_yticks(spots)\n",
    "        ax.set_yticklabels([f'车位 {s}' for s in spots])\n",
    "        ax.invert_yaxis()  # 顶部显示最近的车位\n",
    "\n",
    "        # 设置x轴为时间\n",
    "        min_time = min(a['start'] for a in car_assignments)\n",
    "        max_time = max(a['end'] for a in car_assignments)\n",
    "        ax.set_xlim(min_time - 30, max_time + 30)\n",
    "\n",
    "        # 将分钟数转换为时间格式\n",
    "        def minutes_to_time(x):\n",
    "            hours = int(x // 60)\n",
    "            minutes = int(x % 60)\n",
    "            return f\"{hours:02d}:{minutes:02d}\"\n",
    "\n",
    "        # 设置x轴刻度\n",
    "        ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
    "        ax.set_xticklabels([minutes_to_time(x) for x in ax.get_xticks()])\n",
    "\n",
    "        # 添加标签和标题\n",
    "        ax.set_xlabel('时间')\n",
    "        ax.set_ylabel('车位')\n",
    "        ax.set_title('车位分配甘特图')\n",
    "\n",
    "        # 添加图例（只显示独特的车辆）\n",
    "        handles, labels = ax.get_legend_handles_labels()\n",
    "        by_label = dict(zip(labels, handles))\n",
    "        ax.legend(by_label.values(), by_label.keys(), title='车辆ID',\n",
    "                  bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "\n",
    "    def _plot_parking_layout(self, ax=None):\n",
    "        assignments = self._scheduler.get_assignments()  # 改为self._scheduler\n",
    "        occupied_spots = {info['spot_id'] for info in assignments.values()}\n",
    "\n",
    "        if ax is None:\n",
    "            fig, ax = plt.subplots(figsize=(10, 6))\n",
    "\n",
    "        # 获取所有车位信息\n",
    "        if isinstance(self.scheduler, IntegratedScheduler):\n",
    "            all_spots = [spot[1]\n",
    "                         for spot in self.scheduler.backtracking_scheduler.all_spots]\n",
    "            spot_distances = [spot[0]\n",
    "                              for spot in self.scheduler.backtracking_scheduler.all_spots]\n",
    "        else:\n",
    "            all_spots = [spot[1] for spot in self.scheduler.all_spots]\n",
    "            spot_distances = [spot[0] for spot in self.scheduler.all_spots]\n",
    "\n",
    "        # 绘制入口\n",
    "        entrance = patches.Rectangle(\n",
    "            (0, 0), 1, 1,\n",
    "            facecolor='green',\n",
    "            label='入口'\n",
    "        )\n",
    "        ax.add_patch(entrance)\n",
    "        ax.text(0.5, 0.5, '入口', ha='center', va='center', color='white')\n",
    "\n",
    "        # 绘制车位\n",
    "        for i, (spot, distance) in enumerate(zip(all_spots, spot_distances)):\n",
    "            y_pos = (i + 1) * 1.5\n",
    "            color = 'red' if spot in occupied_spots else 'lightgreen'\n",
    "\n",
    "            # 车位矩形\n",
    "            spot_rect = patches.Rectangle(\n",
    "                (2, y_pos - 0.5), 3, 1,\n",
    "                facecolor=color,\n",
    "                edgecolor='black'\n",
    "            )\n",
    "            ax.add_patch(spot_rect)\n",
    "\n",
    "            # 车位标签\n",
    "            ax.text(\n",
    "                3.5, y_pos,\n",
    "                f'车位 {spot}\\n({distance}m)',\n",
    "                ha='center', va='center'\n",
    "            )\n",
    "\n",
    "            # 连接入口的线\n",
    "            ax.plot(\n",
    "                [1, 2], [0.5, y_pos],\n",
    "                color='gray',\n",
    "                linestyle='--'\n",
    "            )\n",
    "\n",
    "        # 设置图形范围\n",
    "        ax.set_xlim(0, 6)\n",
    "        ax.set_ylim(0, (len(all_spots) + 1) * 1.5)\n",
    "\n",
    "        # 隐藏坐标轴\n",
    "        ax.axis('off')\n",
    "\n",
    "        # 添加标题和图例\n",
    "        ax.set_title('停车场平面布局')\n",
    "\n",
    "        # 创建自定义图例\n",
    "        occupied_patch = patches.Patch(\n",
    "            facecolor='red',\n",
    "            edgecolor='black',\n",
    "            label='已占用'\n",
    "        )\n",
    "        free_patch = patches.Patch(\n",
    "            facecolor='lightgreen',\n",
    "            edgecolor='black',\n",
    "            label='空闲'\n",
    "        )\n",
    "\n",
    "        ax.legend(\n",
    "            handles=[entrance, occupied_patch, free_patch],\n",
    "            loc='upper right'\n",
    "        )\n",
    "\n",
    "    def _plot_utilization(self, ax=None):\n",
    "        total_spots = len(self._scheduler.greedy_scheduler.available_spots) + \\\n",
    "            len(self._scheduler.greedy_scheduler.occupied_spots)  # 改为self._scheduler\n",
    "        if ax is None:\n",
    "            fig, ax = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "        total_spots = len(self.scheduler.greedy_scheduler.available_spots) + \\\n",
    "            len(self.scheduler.greedy_scheduler.occupied_spots)\n",
    "        occupied = len(self.scheduler.greedy_scheduler.occupied_spots)\n",
    "        free = total_spots - occupied\n",
    "        utilization = occupied / total_spots * 100\n",
    "\n",
    "        # 饼图\n",
    "        labels = ['已占用', '空闲']\n",
    "        sizes = [occupied, free]\n",
    "        colors = ['red', 'lightgreen']\n",
    "        explode = (0.1, 0)  # 突出显示已占用部分\n",
    "\n",
    "        ax.pie(sizes, explode=explode, labels=labels, colors=colors,\n",
    "               autopct='%1.1f%%', shadow=True, startangle=90)\n",
    "        ax.axis('equal')  # 保持圆形\n",
    "        ax.set_title(f'车位利用率 ({utilization:.1f}%)')\n",
    "\n",
    "    def _plot_time_distribution(self, ax=None):\n",
    "        assignments = self._scheduler.get_assignments()  # 改为self._scheduler\n",
    "        if ax is None:\n",
    "            fig, ax = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "        assignments = self.scheduler.get_assignments()\n",
    "        arrival_times = [self._time_to_minutes(\n",
    "            info['arrival_time']) for info in assignments.values()]\n",
    "\n",
    "        # 转换为小时\n",
    "        arrival_hours = [t / 60 for t in arrival_times]\n",
    "\n",
    "        # 绘制直方图\n",
    "        sns.histplot(arrival_hours, bins=24, kde=True, ax=ax)\n",
    "        ax.set_xlabel('到达时间 (小时)')\n",
    "        ax.set_ylabel('车辆数量')\n",
    "        ax.set_title('车辆到达时间分布')\n",
    "        ax.set_xticks(range(0, 25, 2))\n",
    "        ax.grid(True)\n",
    "\n",
    "    def _time_to_minutes(self, time_str):\n",
    "        \"\"\"HH:MM -> 分钟数\"\"\"\n",
    "        h, m = map(int, time_str.split(\":\"))\n",
    "        return h * 60 + m\n",
    "    \n",
    "    def generate_assignment_report(self, output_file=None):\n",
    "        \"\"\"生成详细的车位分配报告\"\"\"\n",
    "        try:\n",
    "            assignments = self._scheduler.get_assignments()  # 改为self._scheduler\n",
    "            conflicts = getattr(self._scheduler, 'get_conflicts', lambda: [])()  # 改为self._scheduler\n",
    "            \n",
    "            report = []\n",
    "            report.append(\"=\"*50)\n",
    "            report.append(\"停车场调度系统 - 分配报告\")\n",
    "            report.append(f\"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\")\n",
    "            report.append(\"=\"*50)\n",
    "            report.append(\"\\n[车位分配情况]\")\n",
    "            \n",
    "            # 按车位分组显示\n",
    "            spot_assignments = {}\n",
    "            for car_id, info in assignments.items():\n",
    "                spot_id = info['spot_id']\n",
    "                if spot_id not in spot_assignments:\n",
    "                    spot_assignments[spot_id] = []\n",
    "                spot_assignments[spot_id].append(info)\n",
    "            \n",
    "            # 显示已分配的车位\n",
    "            for spot_id in sorted(spot_assignments.keys()):\n",
    "                report.append(f\"\\n车位 {spot_id}:\")\n",
    "                for assignment in sorted(spot_assignments[spot_id], key=lambda x: x['arrival_time']):\n",
    "                    report.append(f\"  - 车辆 {assignment['car_id']}: {assignment['arrival_time']} 至 {assignment['leave_time']}\")\n",
    "            \n",
    "            # 显示未分配的车位\n",
    "            all_spots = set([spot[1] for spot in self.scheduler.backtracking_scheduler.all_spots])\n",
    "            assigned_spots = set(spot_assignments.keys())\n",
    "            free_spots = all_spots - assigned_spots\n",
    "            if free_spots:\n",
    "                report.append(\"\\n[空闲车位]\")\n",
    "                report.append(\", \".join([f\"车位 {s}\" for s in sorted(free_spots)]))\n",
    "            \n",
    "            # 冲突信息\n",
    "            if conflicts:\n",
    "                report.append(\"\\n[冲突信息]\")\n",
    "                report.append(f\"以下 {len(conflicts)} 辆车未能分配车位:\")\n",
    "                report.append(\", \".join(conflicts))\n",
    "            \n",
    "            # 统计信息\n",
    "            report.append(\"\\n[统计摘要]\")\n",
    "            total_spots = len(all_spots)\n",
    "            occupied = len(assigned_spots)\n",
    "            utilization = occupied / total_spots * 100\n",
    "            report.append(f\"车位总数: {total_spots}\")\n",
    "            report.append(f\"已占用车位: {occupied}\")\n",
    "            report.append(f\"空闲车位: {len(free_spots)}\")\n",
    "            report.append(f\"车位利用率: {utilization:.1f}%\")\n",
    "            report.append(f\"冲突车辆数: {len(conflicts)}\")\n",
    "            \n",
    "            full_report = \"\\n\".join(report)\n",
    "            \n",
    "            # 输出到文件或控制台\n",
    "            if output_file:\n",
    "                with open(output_file, 'w', encoding='utf-8') as f:\n",
    "                    f.write(full_report)\n",
    "                print(f\"报告已保存至 {output_file}\")\n",
    "            else:\n",
    "                print(full_report)\n",
    "            \n",
    "            return full_report\n",
    "            \n",
    "        except Exception as e:\n",
    "            print(f\"生成报告时出错: {str(e)}\")\n",
    "            return \"无法生成报告\"\n",
    "\n",
    "\n",
    "# 示例用法\n",
    "if __name__ == \"__main__\":\n",
    "    try:\n",
    "        # 1. 初始化调度系统\n",
    "        parking_spots = [(50, 1), (100, 2), (150, 3)]\n",
    "        scheduler = IntegratedScheduler(parking_spots)\n",
    "\n",
    "        # 2. 处理车辆\n",
    "        cars_to_schedule = [\n",
    "            {\"car_id\": \"A1\", \"arrival_time\": \"09:00\", \"duration\": 2},\n",
    "            {\"car_id\": \"B2\", \"arrival_time\": \"10:00\", \"duration\": 2},\n",
    "            {\"car_id\": \"C3\", \"arrival_time\": \"09:30\", \"duration\": 1},\n",
    "            {\"car_id\": \"D4\", \"arrival_time\": \"11:00\", \"duration\": 3},\n",
    "            {\"car_id\": \"E5\", \"arrival_time\": \"09:00\", \"duration\": 4}  # 这个会冲突\n",
    "        ]\n",
    "\n",
    "        for car in cars_to_schedule:\n",
    "            success = scheduler.process_car(car)\n",
    "            print(f\"处理车辆 {car['car_id']}: {'成功' if success else '失败'}\")\n",
    "\n",
    "        # 3. 验证调度器状态\n",
    "        print(\"\\n当前占用车位:\", scheduler.greedy_scheduler.occupied_spots)\n",
    "        print(\"可用车位:\", [spot[1] for spot in scheduler.greedy_scheduler.available_spots])\n",
    "\n",
    "        # 4. 创建可视化工具(确保scheduler已正确初始化)\n",
    "        print(\"\\n创建可视化工具...\")\n",
    "        visualizer = ParkingVisualizer(scheduler)  # 确保传入有效的scheduler\n",
    "        \n",
    "        # 5. 生成报告\n",
    "        print(\"\\n=== 生成详细报告 ===\")\n",
    "        report = visualizer.generate_assignment_report()\n",
    "        \n",
    "        # 6. 可视化(仅在有必要时)\n",
    "        if len(scheduler.get_assignments()) > 0:\n",
    "            print(\"\\n=== 生成综合仪表盘 ===\")\n",
    "            visualizer.plot_combined_dashboard()\n",
    "        else:\n",
    "            print(\"无有效分配数据，跳过可视化\")\n",
    "            \n",
    "    except Exception as e:\n",
    "        print(f\"发生错误: {str(e)}\")\n",
    "        import traceback\n",
    "        traceback.print_exc()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52f974fe",
   "metadata": {},
   "source": [
    "**6. 测试与优化**\n",
    "负责人：崔健杨\n",
    "任务：\n",
    "编写测试用例（正常/边界/冲突场景）。\n",
    "分析算法性能（如时间复杂度和等待时间指标）。\n",
    "协同其他成员优化代码和逻辑。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "ba224481",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== 使用 10 个车位进行测试 =====\n",
      "===== 开始测试 =====\n",
      "\n",
      "=== 开始测试正常场景 ===\n",
      "可用车位数量: 10\n",
      "\n",
      "[步骤 1] 处理车辆 car 1:\n",
      "到达时间: 22:19, 停留时长: 1小时\n",
      "分配结果: 成功\n",
      "分配车位: 1\n",
      "离开时间: 23:19\n",
      "当前占用状态:\n",
      "车位 1: 车辆 car 1 离开时间 23:19\n",
      "\n",
      "[步骤 2] 处理车辆 car 2:\n",
      "到达时间: 16:19, 停留时长: 2小时\n",
      "分配结果: 成功\n",
      "分配车位: 6\n",
      "离开时间: 18:19\n",
      "当前占用状态:\n",
      "车位 1: 车辆 car 1 离开时间 23:19\n",
      "车位 6: 车辆 car 2 离开时间 18:19\n",
      "\n",
      "[步骤 3] 处理车辆 car 3:\n",
      "到达时间: 14:19, 停留时长: 1小时\n",
      "分配结果: 成功\n",
      "分配车位: 2\n",
      "离开时间: 15:19\n",
      "当前占用状态:\n",
      "车位 1: 车辆 car 1 离开时间 23:19\n",
      "车位 6: 车辆 car 2 离开时间 18:19\n",
      "车位 2: 车辆 car 3 离开时间 15:19\n",
      "\n",
      "[步骤 4] 处理车辆 car 4:\n",
      "到达时间: 13:19, 停留时长: 4小时\n",
      "分配结果: 成功\n",
      "分配车位: 7\n",
      "离开时间: 17:19\n",
      "当前占用状态:\n",
      "车位 1: 车辆 car 1 离开时间 23:19\n",
      "车位 6: 车辆 car 2 离开时间 18:19\n",
      "车位 2: 车辆 car 3 离开时间 15:19\n",
      "车位 7: 车辆 car 4 离开时间 17:19\n",
      "\n",
      "[步骤 5] 处理车辆 car 5:\n",
      "到达时间: 12:19, 停留时长: 1小时\n",
      "分配结果: 成功\n",
      "分配车位: 3\n",
      "离开时间: 13:19\n",
      "当前占用状态:\n",
      "车位 1: 车辆 car 1 离开时间 23:19\n",
      "车位 6: 车辆 car 2 离开时间 18:19\n",
      "车位 2: 车辆 car 3 离开时间 15:19\n",
      "车位 7: 车辆 car 4 离开时间 17:19\n",
      "车位 3: 车辆 car 5 离开时间 13:19\n",
      "\n",
      "=== 最终分配结果 ===\n",
      "车辆 car 1 → 车位 1 (22:19-23:19)\n",
      "车辆 car 2 → 车位 6 (16:19-18:19)\n",
      "车辆 car 3 → 车位 2 (14:19-15:19)\n",
      "车辆 car 4 → 车位 7 (13:19-17:19)\n",
      "车辆 car 5 → 车位 3 (12:19-13:19)\n",
      "正常场景测试通过 ✓\n",
      "\n",
      "=== 测试边界场景 ===\n",
      "同时到达车辆数量: 10\n",
      "\n",
      "分配结果:\n",
      "车辆car 1 → 车位1\n",
      "车辆car 2 → 车位6\n",
      "车辆car 3 → 车位2\n",
      "车辆car 4 → 车位7\n",
      "车辆car 5 → 车位3\n",
      "车辆car 6 → 车位8\n",
      "车辆car 7 → 车位4\n",
      "车辆car 8 → 车位9\n",
      "车辆car 9 → 车位5\n",
      "车辆car 10 → 车位10\n",
      "边界场景测试通过 ✓\n",
      "\n",
      "=== 测试冲突场景 ===\n",
      "车辆数量: 15, 车位数量: 10\n",
      "\n",
      "成功分配:\n",
      "车辆car 1 → 车位1\n",
      "车辆car 2 → 车位6\n",
      "车辆car 3 → 车位2\n",
      "车辆car 4 → 车位7\n",
      "车辆car 5 → 车位3\n",
      "车辆car 6 → 车位8\n",
      "车辆car 7 → 车位4\n",
      "车辆car 8 → 车位9\n",
      "车辆car 9 → 车位5\n",
      "车辆car 10 → 车位10\n",
      "\n",
      "冲突车辆: ['car 11', 'car 12', 'car 13', 'car 14', 'car 15']\n",
      "冲突场景测试通过 ✓\n",
      "===== 所有测试通过 =====\n",
      "\n",
      "===== 性能分析 (固定10个车位) =====\n",
      "\n",
      "测试配置:\n",
      "车辆数        | 负载描述            | 车位数       \n",
      "----------------------------------------\n",
      "10         | 正常负载            | 10         (车辆数=车位数)\n",
      "20         | 轻度超载            | 10         (车辆数=2倍车位数)\n",
      "50         | 中度超载            | 10         (车辆数=5倍车位数)\n",
      "100        | 重度超载            | 10         (车辆数=10倍车位数)\n",
      "\n",
      "▶ 正在测试 10辆车 (正常负载)...\n",
      "\n",
      "检测到冲突 - 车辆 car 9 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 10 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "贪心算法: 耗时0.0000s | 分配成功: 10/10\n",
      "整合算法: 耗时0.0000s | 分配成功: 10/10\n",
      "\n",
      "▶ 正在测试 20辆车 (轻度超载)...\n",
      "\n",
      "检测到冲突 - 车辆 car 8 与车位 6 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 10 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 13 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 15 与车位 7 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 16 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 17 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 18 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 19 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 20 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "贪心算法: 耗时0.0000s | 分配成功: 10/20\n",
      "整合算法: 耗时0.0010s | 分配成功: 20/20\n",
      "\n",
      "▶ 正在测试 50辆车 (中度超载)...\n",
      "\n",
      "检测到冲突 - 车辆 car 22 与车位 5 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 23 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 26 与车位 8 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 27 与车位 8 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 31 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 32 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 33 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 34 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 35 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 36 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 37 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 38 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 39 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 40 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 41 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 42 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 43 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 44 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 45 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 46 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 47 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 48 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 49 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 50 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "贪心算法: 耗时0.0000s | 分配成功: 10/50\n",
      "整合算法: 耗时12.9693s | 分配成功: 28/50\n",
      "\n",
      "▶ 正在测试 100辆车 (重度超载)...\n",
      "\n",
      "检测到冲突 - 车辆 car 5 与车位 6 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 8 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 11 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 12 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 13 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 14 与车位 6 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 15 与车位 1 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 16 与车位 6 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 20 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 23 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 25 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 成功\n",
      "同步调度器状态...\n",
      "\n",
      "检测到冲突 - 车辆 car 26 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 28 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 30 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 31 与车位 2 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 34 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 35 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 37 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 38 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 39 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 40 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 41 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 42 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 43 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 44 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 45 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 46 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 47 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 48 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 49 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 50 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 51 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 53 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 54 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 55 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 56 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 57 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 58 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 59 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 60 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 61 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 62 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 63 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 64 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 65 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 66 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 67 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 68 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 70 与车位 4 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 71 与车位 4 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 72 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 73 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 74 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 75 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 76 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 77 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 78 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 79 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 80 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 81 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 82 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 83 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 84 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 85 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 86 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 87 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 88 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 89 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 90 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 91 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 92 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 93 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 94 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 95 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 96 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 97 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 98 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 99 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "\n",
      "检测到冲突 - 车辆 car 100 与车位 3 现有分配冲突\n",
      "触发回溯算法...\n",
      "回溯结果: 失败\n",
      "回溯失败，记录冲突\n",
      "贪心算法: 耗时0.0000s | 分配成功: 10/100\n",
      "整合算法: 耗时0.0030s | 分配成功: 31/100\n",
      "\n",
      "🔍 性能测试报告:\n",
      "场景       | 算法         | 耗时(s)    | 成功率        | 效率(车/s)   \n",
      "-----------------------------------------------------------------\n",
      "10       | 贪心算法       | 0.0000 | 10/10      | inf\n",
      "10       | 整合算法       | 0.0000 | 10/10      | inf\n",
      "20       | 贪心算法       | 0.0000 | 10/20      | inf\n",
      "20       | 整合算法       | 0.0010 | 20/20      | 19522.0\n",
      "50       | 贪心算法       | 0.0000 | 10/50      | inf\n",
      "50       | 整合算法       | 12.9693 | 28/50      | 3.9\n",
      "100      | 贪心算法       | 0.0000 | 10/100     | inf\n",
      "100      | 整合算法       | 0.0030 | 31/100     | 33190.7\n",
      "\n",
      "===== 演示完整流程 =====\n",
      "处理车辆 car 1: 成功\n",
      "处理车辆 car 2: 成功\n",
      "处理车辆 car 3: 成功\n",
      "处理车辆 car 4: 成功\n",
      "处理车辆 car 5: 成功\n",
      "处理车辆 car 6: 成功\n",
      "处理车辆 car 7: 成功\n",
      "处理车辆 car 8: 成功\n",
      "\n",
      "最终分配结果:\n",
      "车辆 car 1 → 车位 1 (12:19-15:19)\n",
      "车辆 car 2 → 车位 1 (22:19-26:19)\n",
      "车辆 car 3 → 车位 6 (15:19-16:19)\n",
      "车辆 car 4 → 车位 6 (22:19-24:19)\n",
      "车辆 car 5 → 车位 2 (16:19-17:19)\n",
      "车辆 car 6 → 车位 7 (12:19-15:19)\n",
      "车辆 car 7 → 车位 2 (18:19-21:19)\n",
      "车辆 car 8 → 车位 7 (20:19-23:19)\n",
      "\n",
      "生成可视化图表...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\86150\\AppData\\Local\\Temp\\ipykernel_33556\\1027364159.py:120: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.\n",
      "  ax.set_xticklabels([minutes_to_time(x) for x in ax.get_xticks()])\n",
      "c:\\ProgramData\\anaconda3\\Lib\\site-packages\\seaborn\\_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1200 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "import random\n",
    "from datetime import datetime, timedelta\n",
    "import json\n",
    "\n",
    "# 固定使用10个车位\n",
    "NUM_SPOTS = 10\n",
    "\n",
    "\n",
    "def generate_car_data(num_cars):\n",
    "    \"\"\"生成车辆数据，使用固定的10个车位\"\"\"\n",
    "    cars = []\n",
    "    spots = [f\"Spot {i+1}\" for i in range(NUM_SPOTS)]\n",
    "    spot_distances = [50 + 50 * (i % 5) for i in range(NUM_SPOTS)]  # 50m, 100m, 150m...\n",
    "\n",
    "    for i in range(num_cars):\n",
    "        arrival_time = datetime.now() + timedelta(hours=random.randint(0, 10))\n",
    "        duration_hours = random.randint(1, 4)  # 已经是整数\n",
    "        departure_time = arrival_time + timedelta(hours=duration_hours)\n",
    "\n",
    "        car = {\n",
    "            \"car_id\": f\"car {i+1}\",\n",
    "            \"arrival_time\": arrival_time.strftime(\"%H:%M\"),\n",
    "            \"departure_time\": departure_time.strftime(\"%H:%M\"),\n",
    "            \"duration\": duration_hours,  # 确保是整数\n",
    "            \"assigned_spot\": random.choice(spots)\n",
    "        }\n",
    "        cars.append(car)\n",
    "\n",
    "    return cars, spot_distances\n",
    "\n",
    "def prepare_test_data(cars, spot_distances):\n",
    "    \"\"\"准备测试需要的数据格式\"\"\"\n",
    "    parking_spots = [(spot_distances[i], i+1) for i in range(len(spot_distances))]\n",
    "    test_cars = [{\n",
    "        \"car_id\": car[\"car_id\"],\n",
    "        \"arrival_time\": car[\"arrival_time\"],\n",
    "        \"duration\": int(car[\"duration\"])  # 强制转换为整数\n",
    "    } for car in cars]\n",
    "    return parking_spots, test_cars\n",
    "\n",
    "def run_all_tests():\n",
    "    \"\"\"运行所有测试用例\"\"\"\n",
    "    print(\"===== 开始测试 =====\")\n",
    "    test_normal_case()\n",
    "    print(\"正常场景测试通过 ✓\")\n",
    "    test_edge_cases()\n",
    "    print(\"边界场景测试通过 ✓\")\n",
    "    test_conflict_cases()\n",
    "    print(\"冲突场景测试通过 ✓\")\n",
    "    print(\"===== 所有测试通过 =====\")\n",
    "\n",
    "def test_normal_case():\n",
    "    \"\"\"测试正常场景 - 使用5辆车和10个车位\"\"\"\n",
    "    cars, spot_distances = generate_car_data(num_cars=5)\n",
    "    parking_spots, test_cars = prepare_test_data(cars, spot_distances)\n",
    "    scheduler = IntegratedScheduler(parking_spots)\n",
    "\n",
    "    print(\"\\n=== 开始测试正常场景 ===\")\n",
    "    print(f\"可用车位数量: {NUM_SPOTS}\")\n",
    "    for i, car in enumerate(test_cars, 1):\n",
    "        print(f\"\\n[步骤 {i}] 处理车辆 {car['car_id']}:\")\n",
    "        print(f\"到达时间: {car['arrival_time']}, 停留时长: {car['duration']}小时\")\n",
    "\n",
    "        success = scheduler.process_car(car)\n",
    "        print(f\"分配结果: {'成功' if success else '失败'}\")\n",
    "\n",
    "        if success:\n",
    "            assignments = scheduler.get_assignments()\n",
    "            current = assignments[car[\"car_id\"]]\n",
    "            print(f\"分配车位: {current['spot_id']}\")\n",
    "            print(f\"离开时间: {current['leave_time']}\")\n",
    "\n",
    "        print(\"当前占用状态:\")\n",
    "        for spot, (vid, ltime) in scheduler.greedy_scheduler.occupied_spots.items():\n",
    "            print(f\"车位 {spot}: 车辆 {vid} 离开时间 {ltime}\")\n",
    "\n",
    "    assignments = scheduler.get_assignments()\n",
    "    print(\"\\n=== 最终分配结果 ===\")\n",
    "    for car_id, info in assignments.items():\n",
    "        print(f\"车辆 {car_id} → 车位 {info['spot_id']} ({info['arrival_time']}-{info['leave_time']})\")\n",
    "\n",
    "    assert len(assignments) == 5\n",
    "    assert len(set([info['spot_id'] for info in assignments.values()])) == 5, \"应分配到不同车位\"\n",
    "    assert scheduler.get_conflicts() == []\n",
    "\n",
    "def test_edge_cases():\n",
    "    \"\"\"测试边界场景 - 使用10辆车刚好占满所有车位\"\"\"\n",
    "    cars, spot_distances = generate_car_data(num_cars=10)\n",
    "    parking_spots, test_cars = prepare_test_data(cars, spot_distances)\n",
    "    \n",
    "    # 调整所有车辆同时到达\n",
    "    same_time = \"12:00\"\n",
    "    for car in test_cars:\n",
    "        car[\"arrival_time\"] = same_time\n",
    "    \n",
    "    scheduler = IntegratedScheduler(parking_spots)\n",
    "\n",
    "    print(\"\\n=== 测试边界场景 ===\")\n",
    "    print(f\"同时到达车辆数量: {len(test_cars)}\")\n",
    "    \n",
    "    success_count = 0\n",
    "    for car in test_cars:\n",
    "        if scheduler.process_car(car):\n",
    "            success_count += 1\n",
    "\n",
    "    assignments = scheduler.get_assignments()\n",
    "    print(\"\\n分配结果:\")\n",
    "    for car_id, info in assignments.items():\n",
    "        print(f\"车辆{car_id} → 车位{info['spot_id']}\")\n",
    "\n",
    "    assert success_count == 10, \"应成功分配所有车辆\"\n",
    "    assert len(set([info['spot_id'] for info in assignments.values()])) == 10, \"应使用所有车位\"\n",
    "    assert scheduler.get_conflicts() == []\n",
    "\n",
    "def test_conflict_cases():\n",
    "    \"\"\"测试冲突场景 - 使用15辆车尝试分配到10个车位\"\"\"\n",
    "    cars, spot_distances = generate_car_data(num_cars=15)\n",
    "    parking_spots, test_cars = prepare_test_data(cars, spot_distances)\n",
    "    \n",
    "    # 调整所有车辆同时到达\n",
    "    same_time = \"12:00\"\n",
    "    for car in test_cars:\n",
    "        car[\"arrival_time\"] = same_time\n",
    "    \n",
    "    scheduler = IntegratedScheduler(parking_spots)\n",
    "\n",
    "    print(\"\\n=== 测试冲突场景 ===\")\n",
    "    print(f\"车辆数量: {len(test_cars)}, 车位数量: {NUM_SPOTS}\")\n",
    "    \n",
    "    success_count = 0\n",
    "    conflicts = []\n",
    "    for car in test_cars:\n",
    "        if not scheduler.process_car(car):\n",
    "            conflicts.append(car[\"car_id\"])\n",
    "\n",
    "    assignments = scheduler.get_assignments()\n",
    "    print(\"\\n成功分配:\")\n",
    "    for car_id, info in assignments.items():\n",
    "        print(f\"车辆{car_id} → 车位{info['spot_id']}\")\n",
    "    \n",
    "    print(\"\\n冲突车辆:\", conflicts)\n",
    "\n",
    "    assert len(assignments) == 10, \"应正好分配10辆车\"\n",
    "    assert len(conflicts) == 5, \"应有5辆车冲突\"\n",
    "    assert len(set([info['spot_id'] for info in assignments.values()])) == 10, \"应使用所有车位\"\n",
    "\n",
    "def analyze_performance():\n",
    "    \"\"\"性能分析 - 使用不同车辆数量测试10个车位的性能\"\"\"\n",
    "    print(\"\\n===== 性能分析 (固定10个车位) =====\")\n",
    "\n",
    "    # 测试场景设计\n",
    "    test_scales = [\n",
    "        (10, \"正常负载\", \"车辆数=车位数\"),\n",
    "        (20, \"轻度超载\", \"车辆数=2倍车位数\"),\n",
    "        (50, \"中度超载\", \"车辆数=5倍车位数\"),\n",
    "        (100, \"重度超载\", \"车辆数=10倍车位数\")\n",
    "    ]\n",
    "\n",
    "    # 确保时间计算使用整数\n",
    "    def format_time(minutes):\n",
    "        \"\"\"安全格式化时间，处理整数和浮点数\"\"\"\n",
    "        if isinstance(minutes, float):\n",
    "            minutes = int(round(minutes))\n",
    "        return f\"{minutes//60:02d}:{minutes%60:02d}\"\n",
    "\n",
    "    # 打印测试配置表\n",
    "    print(\"\\n测试配置:\")\n",
    "    print(f\"{'车辆数':<10} | {'负载描述':<15} | {'车位数':<10}\")\n",
    "    print(\"-\" * 40)\n",
    "    for num_cars, desc, ratio in test_scales:\n",
    "        print(f\"{num_cars:<10} | {desc:<15} | {NUM_SPOTS:<10} ({ratio})\")\n",
    "    \n",
    "    # 执行性能测试\n",
    "    results = []\n",
    "    for num_cars, desc, ratio in test_scales:\n",
    "        print(f\"\\n▶ 正在测试 {num_cars}辆车 ({desc})...\")\n",
    "        cars, spot_distances = generate_car_data(num_cars)\n",
    "        parking_spots, test_cars = prepare_test_data(cars, spot_distances)\n",
    "\n",
    "        # 贪心算法测试\n",
    "        greedy_start = time.time()\n",
    "        greedy_scheduler = ParkingScheduler(parking_spots.copy())\n",
    "        greedy_success = 0\n",
    "        for car in test_cars:\n",
    "            # 确保传入的时间是整数\n",
    "            car_duration = int(car[\"duration\"])\n",
    "            if greedy_scheduler.assign_spot(car[\"car_id\"], car[\"arrival_time\"], car_duration):\n",
    "                greedy_success += 1\n",
    "        greedy_time = time.time() - greedy_start\n",
    "\n",
    "        # 整合算法测试\n",
    "        int_start = time.time()\n",
    "        int_scheduler = IntegratedScheduler(parking_spots.copy())\n",
    "        int_success = 0\n",
    "        for car in test_cars:\n",
    "            # 确保传入的时间是整数\n",
    "            car[\"duration\"] = int(car[\"duration\"])\n",
    "            if int_scheduler.process_car(car):\n",
    "                int_success += 1\n",
    "        int_time = time.time() - int_start\n",
    "\n",
    "        # 记录结果\n",
    "        results.append({\n",
    "            \"车辆数\": num_cars,\n",
    "            \"贪心算法\": {\n",
    "                \"耗时\": greedy_time,\n",
    "                \"成功率\": f\"{greedy_success}/{num_cars}\",\n",
    "                \"成功率%\": round(greedy_success/num_cars*100, 1)\n",
    "            },\n",
    "            \"整合算法\": {\n",
    "                \"耗时\": int_time,\n",
    "                \"成功率\": f\"{int_success}/{num_cars}\",\n",
    "                \"成功率%\": round(int_success/num_cars*100, 1)\n",
    "            }\n",
    "        })\n",
    "\n",
    "        # 打印实时结果\n",
    "        print(f\"贪心算法: 耗时{greedy_time:.4f}s | 分配成功: {greedy_success}/{num_cars}\")\n",
    "        print(f\"整合算法: 耗时{int_time:.4f}s | 分配成功: {int_success}/{num_cars}\")\n",
    "\n",
    "    # 生成性能报告\n",
    "    print(\"\\n🔍 性能测试报告:\")\n",
    "    print(f\"{'场景':<8} | {'算法':<10} | {'耗时(s)':<8} | {'成功率':<10} | {'效率(车/s)':<10}\")\n",
    "    print(\"-\" * 65)\n",
    "    for res in results:\n",
    "        num = res[\"车辆数\"]\n",
    "        for algo in [\"贪心算法\", \"整合算法\"]:\n",
    "            data = res[algo]\n",
    "            efficiency = num / data[\"耗时\"] if data[\"耗时\"] > 0 else float('inf')\n",
    "            print(f\"{num:<8} | {algo:<10} | {data['耗时']:.4f} | {data['成功率']:<10} | {efficiency:.1f}\")\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    try:\n",
    "        # 固定随机种子以便重复测试\n",
    "        random.seed(42)\n",
    "        \n",
    "        print(f\"===== 使用 {NUM_SPOTS} 个车位进行测试 =====\")\n",
    "        \n",
    "        # 运行所有测试\n",
    "        run_all_tests()\n",
    "        \n",
    "        # 运行性能分析\n",
    "        analyze_performance()\n",
    "        \n",
    "        # 演示完整流程\n",
    "        print(\"\\n===== 演示完整流程 =====\")\n",
    "        cars, spot_distances = generate_car_data(num_cars=8)\n",
    "        parking_spots, test_cars = prepare_test_data(cars, spot_distances)\n",
    "        scheduler = IntegratedScheduler(parking_spots)\n",
    "\n",
    "        for car in test_cars:\n",
    "            success = scheduler.process_car(car)\n",
    "            print(f\"处理车辆 {car['car_id']}: {'成功' if success else '失败'}\")\n",
    "\n",
    "        print(\"\\n最终分配结果:\")\n",
    "        assignments = scheduler.get_assignments()\n",
    "        for car_id, info in assignments.items():\n",
    "            print(f\"车辆 {car_id} → 车位 {info['spot_id']} ({info['arrival_time']}-{info['leave_time']})\")\n",
    "            \n",
    "        if len(assignments) > 0:\n",
    "            visualizer = ParkingVisualizer(scheduler)\n",
    "            print(\"\\n生成可视化图表...\")\n",
    "            visualizer.plot_combined_dashboard()\n",
    "            \n",
    "    except Exception as e:\n",
    "        print(f\"发生错误: {str(e)}\")\n",
    "        import traceback\n",
    "        traceback.print_exc()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
